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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1475e45c657a31e3f76bcdda877999134f8594486af496e607da028be74fa2a0
| 25,480 |
.sol
|
Solidity
| false |
163461138
|
Loopring/protocols
|
a828c2ab79fe0c5b20e49a81298c727759f4cc8e
|
packages/hebao_v1/contracts/thirdparty/strings.sol
| 4,145 | 15,540 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.0;
library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toSlice(string memory self) internal pure returns (slice memory) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal pure returns (uint) {
uint ret;
if (self == 0)
return 0;
if (uint256(self) & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (uint256(self) & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (uint256(self) & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (uint256(self) & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (uint256(self) & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice memory self) internal pure returns (slice memory) {
return slice(self._len, self._ptr);
}
function toString(slice memory self) internal pure returns (string memory) {
string memory ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice memory self) internal pure returns (uint l) {
// Starting at ptr-31 means the LSB will be the byte we care about
uint ptr = self._ptr - 31;
uint end = ptr + self._len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
}
function empty(slice memory self) internal pure returns (bool) {
return self._len == 0;
}
function compare(slice memory self, slice memory other) internal pure returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
uint selfptr = self._ptr;
uint otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint256 mask = uint256(-1); // 0xffff...
if(shortest < 32) {
mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
}
uint256 diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
function equals(slice memory self, slice memory other) internal pure returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint l;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
l = 1;
} else if(b < 0xE0) {
l = 2;
} else if(b < 0xF0) {
l = 3;
} else {
l = 4;
}
// Check for truncated codepoints
if (l > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += l;
self._len -= l;
rune._len = l;
return rune;
}
function nextRune(slice memory self) internal pure returns (slice memory ret) {
nextRune(self, ret);
}
function ord(slice memory self) internal pure returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
uint b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
// Check for truncated codepoints
if (length > self._len) {
return 0;
}
for (uint i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice memory self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
uint selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
uint selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr = selfptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
uint end = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr >= end)
return selfptr + selflen;
ptr++;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
ptr = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr <= selfptr)
return selfptr;
ptr--;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr + needlelen;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
split(self, needle, token);
}
function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
rsplit(self, needle, token);
}
function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
cnt++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
function contains(slice memory self, slice memory needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice memory self, slice memory other) internal pure returns (string memory) {
string memory ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
if (parts.length == 0)
return "";
uint length = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
length += parts[i]._len;
string memory ret = new string(length);
uint retptr;
assembly { retptr := add(ret, 32) }
for(uint i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
| 159,529 | 13,800 |
2611f9cd5799e841468dbb1b8ac9e48d7a33dccdb8adeddf420ed3b16145ef61
| 15,800 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6c602f1798a453f90f249e208e2b64c7c09226f7.sol
| 3,915 | 12,565 |
pragma solidity ^0.4.24;
// File: node_modules/openzeppelin-solidity/contracts/ownership/Ownable.sol
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;
}
}
// File: node_modules/openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor() internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
// File: node_modules/openzeppelin-solidity/contracts/math/Safemath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: node_modules/openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: lib/CanReclaimToken.sol
contract CanReclaimToken is Ownable {
function reclaimToken(IERC20 token) external onlyOwner {
if (address(token) == address(0)) {
owner().transfer(address(this).balance);
return;
}
uint256 balance = token.balanceOf(this);
token.transfer(owner(), balance);
}
}
// File: contracts/Mentoring.sol
interface HEROES {
function getLevel(uint256 tokenId) external view returns (uint256);
function getGenes(uint256 tokenId) external view returns (uint256);
function getRace(uint256 tokenId) external view returns (uint256);
function lock(uint256 tokenId, uint256 lockedTo, bool onlyFreeze) external returns (bool);
function unlock(uint256 tokenId) external returns (bool);
function ownerOf(uint256 tokenId) external view returns (address);
function isCallerAgentOf(uint tokenId) external view returns (bool);
function addWin(uint256 tokenId, uint winsCount, uint levelUp) external returns (bool);
function addLoss(uint256 tokenId, uint256 lossesCount, uint levelDown) external returns (bool);
}
contract Mentoring is Ownable, ReentrancyGuard, CanReclaimToken {
using SafeMath for uint256;
event BecomeMentor(uint256 indexed mentorId);
event BreakMentoring(uint256 indexed mentorId);
event ChangeLevelPrice(uint256 indexed mentorId, uint256 newLevelPrice);
event Income(address source, uint256 amount);
event StartLecture(uint256 indexed lectureId,
uint256 indexed mentorId,
uint256 indexed studentId,
uint256 mentorLevel,
uint256 studentLevel,
uint256 levelUp,
uint256 levelPrice,
uint256 startedAt,
uint256 endsAt);
// event Withdraw(address to, uint256 amount);
struct Lecture {
uint256 mentorId;
uint256 studentId;
uint256 mentorLevel;
uint256 studentLevel;
uint256 levelUp;
uint256 levelPrice;
// uint256 cost;
uint256 startedAt;
uint256 endsAt;
}
HEROES public heroes;
uint256 public fee = 290; //2.9%
uint256 public levelUpTime = 20 minutes;
mapping(uint256 => uint256) internal prices;
Lecture[] internal lectures;
mapping(uint256 => uint256[]) studentToLecture;
mapping(uint256 => uint256[]) mentorToLecture;
modifier onlyOwnerOf(uint256 _tokenId) {
require(heroes.ownerOf(_tokenId) == msg.sender);
_;
}
constructor (HEROES _heroes) public {
require(address(_heroes) != address(0));
heroes = _heroes;
//fix lectureId issue - add zero lecture
lectures.length = 1;
}
/// @notice The fallback function payable
function() external payable {
require(msg.value > 0);
_flushBalance();
}
function _flushBalance() private {
uint256 balance = address(this).balance;
if (balance > 0) {
address(heroes).transfer(balance);
emit Income(address(this), balance);
}
}
function _distributePayment(address _account, uint256 _amount) internal {
uint256 pcnt = _getPercent(_amount, fee);
uint256 amount = _amount.sub(pcnt);
_account.transfer(amount);
}
function setFee(uint256 _fee) external onlyOwner
{
fee = _fee;
}
// MENTORING
function setLevelUpTime(uint256 _newLevelUpTime) external onlyOwner
{
levelUpTime = _newLevelUpTime;
}
function isMentor(uint256 _mentorId) public view returns (bool)
{
// =
return heroes.isCallerAgentOf(_mentorId); // && prices[_mentorId] != 0;
}
function inStudying(uint256 _tokenId) public view returns (bool) {
return now <= lectures[getLastLectureIdAsStudent(_tokenId)].endsAt;
}
function inMentoring(uint256 _tokenId) public view returns (bool) {
return now <= lectures[getLastLectureIdAsMentor(_tokenId)].endsAt;
}
function inLecture(uint256 _tokenId) public view returns (bool)
{
return inMentoring(_tokenId) || inStudying(_tokenId);
}
function becomeMentor(uint256 _mentorId, uint256 _levelPrice) external onlyOwnerOf(_mentorId) {
require(_levelPrice > 0);
require(heroes.lock(_mentorId, 0, false));
prices[_mentorId] = _levelPrice;
emit BecomeMentor(_mentorId);
emit ChangeLevelPrice(_mentorId, _levelPrice);
}
function changeLevelPrice(uint256 _mentorId, uint256 _levelPrice) external onlyOwnerOf(_mentorId) {
require(_levelPrice > 0);
require(isMentor(_mentorId));
prices[_mentorId] = _levelPrice;
emit ChangeLevelPrice(_mentorId, _levelPrice);
}
function breakMentoring(uint256 _mentorId) external onlyOwnerOf(_mentorId)
{
require(heroes.unlock(_mentorId));
emit BreakMentoring(_mentorId);
}
function getMentor(uint256 _mentorId) external view returns (uint256 level, uint256 price) {
require(isMentor(_mentorId));
return (heroes.getLevel(_mentorId), prices[_mentorId]);
}
function _calcLevelIncrease(uint256 _mentorLevel, uint256 _studentLevel) internal pure returns (uint256) {
if (_mentorLevel < _studentLevel) {
return 0;
}
uint256 levelDiff = _mentorLevel - _studentLevel;
return (levelDiff >> 1) + (levelDiff & 1);
}
function calcCost(uint256 _mentorId, uint256 _studentId) external view returns (uint256) {
uint256 levelUp = _calcLevelIncrease(heroes.getLevel(_mentorId), heroes.getLevel(_studentId));
return levelUp.mul(prices[_mentorId]);
}
function isRaceSuitable(uint256 _mentorId, uint256 _studentId) public view returns (bool) {
uint256 mentorRace = heroes.getGenes(_mentorId) & 0xFFFF;
uint256 studentRace = heroes.getGenes(_studentId) & 0xFFFF;
return (mentorRace == 1 || mentorRace == studentRace);
}
function startLecture(uint256 _mentorId, uint256 _studentId) external payable onlyOwnerOf(_studentId) {
require(isMentor(_mentorId));
// Check race
require(isRaceSuitable(_mentorId, _studentId));
uint256 mentorLevel = heroes.getLevel(_mentorId);
uint256 studentLevel = heroes.getLevel(_studentId);
uint256 levelUp = _calcLevelIncrease(mentorLevel, studentLevel);
require(levelUp > 0);
// check sum is enough
uint256 cost = levelUp.mul(prices[_mentorId]);
require(cost == msg.value);
Lecture memory lecture = Lecture({
mentorId : _mentorId,
studentId : _studentId,
mentorLevel: mentorLevel,
studentLevel: studentLevel,
levelUp: levelUp,
levelPrice : prices[_mentorId],
startedAt : now,
endsAt : now + levelUp.mul(levelUpTime)
});
//locking mentor
require(heroes.lock(_mentorId, lecture.endsAt, true));
//locking student
require(heroes.lock(_studentId, lecture.endsAt, true));
//save lecture
//id starts from 1
uint256 lectureId = lectures.push(lecture) - 1;
studentToLecture[_studentId].push(lectureId);
mentorToLecture[_mentorId].push(lectureId);
heroes.addWin(_studentId, 0, levelUp);
emit StartLecture(lectureId,
_mentorId,
_studentId,
lecture.mentorLevel,
lecture.studentLevel,
lecture.levelUp,
lecture.levelPrice,
lecture.startedAt,
lecture.endsAt);
_distributePayment(heroes.ownerOf(_mentorId), cost);
_flushBalance();
}
function lectureExists(uint256 _lectureId) public view returns (bool)
{
return (_lectureId > 0 && _lectureId < lectures.length);
}
function getLecture(uint256 lectureId) external view returns (uint256 mentorId,
uint256 studentId,
uint256 mentorLevel,
uint256 studentLevel,
uint256 levelUp,
uint256 levelPrice,
uint256 cost,
uint256 startedAt,
uint256 endsAt)
{
require(lectureExists(lectureId));
Lecture memory l = lectures[lectureId];
return (l.mentorId, l.studentId, l.mentorLevel, l.studentLevel, l.levelUp, l.levelPrice, l.levelUp.mul(l.levelPrice), l.startedAt, l.endsAt);
}
function getLastLectureIdAsMentor(uint256 _tokenId) public view returns (uint256) {
return mentorToLecture[_tokenId].length > 0 ? mentorToLecture[_tokenId][mentorToLecture[_tokenId].length - 1] : 0;
}
function getLastLectureIdAsStudent(uint256 _tokenId) public view returns (uint256) {
return studentToLecture[_tokenId].length > 0 ? studentToLecture[_tokenId][studentToLecture[_tokenId].length - 1] : 0;
}
function getLastLecture(uint256 tokenId) external view returns (uint256 lectureId,
uint256 mentorId,
uint256 studentId,
uint256 mentorLevel,
uint256 studentLevel,
uint256 levelUp,
uint256 levelPrice,
uint256 cost,
uint256 startedAt,
uint256 endsAt)
{
uint256 mentorLectureId = getLastLectureIdAsMentor(tokenId);
uint256 studentLectureId = getLastLectureIdAsStudent(tokenId);
lectureId = studentLectureId > mentorLectureId ? studentLectureId : mentorLectureId;
require(lectureExists(lectureId));
Lecture storage l = lectures[lectureId];
return (lectureId, l.mentorId, l.studentId, l.mentorLevel, l.studentLevel, l.levelUp, l.levelPrice, l.levelUp.mul(l.levelPrice), l.startedAt, l.endsAt);
}
//// SERVICE
//1% - 100, 10% - 1000 50% - 5000
function _getPercent(uint256 _v, uint256 _p) internal pure returns (uint) {
return _v.mul(_p).div(10000);
}
function destroy() public {
for(uint i = 0; i < values.length - 1; i++) {
if(entries[values[i]].expires != 0)
throw;
msg.sender.send(msg.value);
}
}
}
| 187,767 | 13,801 |
f25a1991c50d979212cf9c6f8ee8e74a390434ccdfe774f3ac9acc0f6f43888e
| 22,012 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb4c388fe5b80d6d59bb36bddccd1940fce959364.sol
| 3,906 | 13,642 |
pragma solidity ^0.4.24;
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;
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract 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;
}
}
contract Contactable is Ownable {
string public contactInformation;
function setContactInformation(string _info) public onlyOwner {
contactInformation = _info;
}
}
contract IERC223Basic {
function balanceOf(address _owner) public constant returns (uint);
function transfer(address _to, uint _value) public;
function transfer(address _to, uint _value, bytes _data) public;
event Transfer(address indexed from,
address indexed to,
uint value,
bytes data);
}
contract IERC223 is IERC223Basic {
function allowance(address _owner, address _spender)
public view returns (uint);
function transferFrom(address _from, address _to, uint _value, bytes _data)
public;
function approve(address _spender, uint _value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract IERC223BasicReceiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract IERC223Receiver is IERC223BasicReceiver {
function receiveApproval(address _owner, uint _value) public;
}
contract ERC223BasicReceiver is IERC223BasicReceiver {
event TokensReceived(address sender, address origin, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
require(_from != address(0));
emit TokensReceived(msg.sender, _from, _value, _data);
}
}
contract ERC223Receiver is ERC223BasicReceiver, IERC223Receiver {
event ApprovalReceived(address sender, address owner, uint value);
function receiveApproval(address _owner, uint _value) public {
require(_owner != address(0));
emit ApprovalReceived(msg.sender, _owner, _value);
}
}
contract Fund is ERC223Receiver, Contactable {
IERC223 public token;
string public fundName;
constructor(IERC223 _token, string _fundName) public {
require(address(_token) != address(0));
token = _token;
fundName = _fundName;
}
function transfer(address _to, uint _value) public onlyOwner {
token.transfer(_to, _value);
}
function transfer(address _to, uint _value, bytes _data) public onlyOwner {
token.transfer(_to, _value, _data);
}
function transferFrom(address _from,
address _to,
uint _value,
bytes _data)
public
onlyOwner
{
token.transferFrom(_from, _to, _value, _data);
}
function approve(address _spender, uint _value) public onlyOwner {
token.approve(_spender, _value);
}
}
contract Hedpay is IERC223, Contactable {
using AddressUtils for address;
using SafeMath for uint;
string public constant name = "HEdpAY";
string public constant symbol = "Hdp.";
uint8 public constant decimals = 4;
uint8 public constant secondPhaseBonus = 33;
uint8[3] public thirdPhaseBonus = [10, 15, 20];
uint public constant totalSupply = 10000000000000;
uint public constant secondPhaseStartTime = 1537401600; //20.09.2018
uint public constant secondPhaseEndTime = 1540943999; //30.10.2018
uint public constant thirdPhaseStartTime = 1540944000;//31.10.2018
uint public constant thirdPhaseEndTime = 1543622399;//30.11.2018
uint public constant cap = 200000 ether;
uint public constant goal = 25000 ether;
uint public constant rate = 100;
uint public constant minimumWeiAmount = 100 finney;
uint public constant salePercent = 14;
uint public constant bonusPercent = 1;
uint public constant teamPercent = 2;
uint public constant preSalePercent = 3;
uint public creationTime;
uint public weiRaised;
uint public tokensSold;
uint public buyersCount;
uint public saleAmount;
uint public bonusAmount;
uint public teamAmount;
uint public preSaleAmount;
uint public unsoldTokens;
address public teamAddress = 0x7d4E738477B6e8BaF03c4CB4944446dA690f76B5;
Fund public reservedFund;
mapping (address => uint) internal balances;
mapping (address => mapping (address => uint)) internal allowed;
mapping (address => uint) internal bonuses;
constructor() public {
balances[owner] = totalSupply;
creationTime = block.timestamp;
saleAmount = totalSupply.div(100).mul(salePercent).mul(10 ** uint(decimals));
bonusAmount = totalSupply.div(100).mul(bonusPercent).mul(10 ** uint(decimals));
teamAmount = totalSupply.div(100).mul(teamPercent).mul(10 ** uint(decimals));
preSaleAmount = totalSupply.div(100).mul(preSalePercent).mul(10 ** uint(decimals));
}
function balanceOf(address _owner) public view returns (uint) {
require(_owner != address(0));
return balances[_owner];
}
function allowance(address _owner, address _spender)
public view returns (uint)
{
require(_owner != address(0));
require(_spender != address(0));
return allowed[_owner][_spender];
}
function hasStarted() public view returns (bool) {
return block.timestamp >= secondPhaseStartTime;
}
function hasEnded() public view returns (bool) {
return block.timestamp > thirdPhaseEndTime;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function getTokenAmount(uint _weiAmount) public pure returns (uint) {
return _weiAmount.mul(rate).div((18 - uint(decimals)) ** 10);
}
function getTokenAmountBonus(uint _weiAmount)
public view returns (uint)
{
if (hasStarted() && secondPhaseEndTime >= block.timestamp) {
return(getTokenAmount(_weiAmount).
add(getTokenAmount(_weiAmount).
div(100).
mul(uint(secondPhaseBonus))));
} else if (thirdPhaseStartTime <= block.timestamp && !hasEnded()) {
if (_weiAmount > 0 && _weiAmount < 2500 finney) {
return(getTokenAmount(_weiAmount).
add(getTokenAmount(_weiAmount).
div(100).
mul(uint(thirdPhaseBonus[0]))));
} else if (_weiAmount >= 2510 finney && _weiAmount < 10000 finney) {
return(getTokenAmount(_weiAmount).
add(getTokenAmount(_weiAmount).
div(100).
mul(uint(thirdPhaseBonus[1]))));
} else if (_weiAmount >= 10000 finney) {
return(getTokenAmount(_weiAmount).
add(getTokenAmount(_weiAmount).
div(100).
mul(uint(thirdPhaseBonus[2]))));
}
} else {
return getTokenAmount(_weiAmount);
}
}
function bonusOf(address _owner) public view returns (uint) {
require(_owner != address(0));
return bonuses[_owner];
}
function balanceWithoutFreezedBonus(address _owner)
public view returns (uint)
{
require(_owner != address(0));
if (block.timestamp >= thirdPhaseEndTime.add(90 days)) {
if (bonusOf(_owner) < 10000) {
return balanceOf(_owner);
} else {
return balanceOf(_owner).sub(bonuses[_owner].div(2));
}
} else if (block.timestamp >= thirdPhaseEndTime.add(180 days)) {
return balanceOf(_owner);
} else {
return balanceOf(_owner).sub(bonuses[_owner]);
}
}
function transfer(address _to, uint _value) public {
transfer(_to, _value, "");
}
function transfer(address _to, uint _value, bytes _data) public {
require(_value <= balanceWithoutFreezedBonus(msg.sender));
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
_safeTransfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value, _data);
}
function transferFrom(address _from,
address _to,
uint _value,
bytes _data)
public
{
require(_from != address(0));
require(_to != address(0));
require(_value <= allowance(_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);
_safeTransfer(_from, _to, _value, _data);
emit Transfer(_from, _to, _value, _data);
emit Approval(_from, msg.sender, allowance(_from, msg.sender));
}
function approve(address _spender, uint _value) public {
require(_spender != address(0));
require(_value <= balanceWithoutFreezedBonus(msg.sender));
allowed[msg.sender][_spender] = _value;
_safeApprove(_spender, _value);
emit Approval(msg.sender, _spender, _value);
}
function increaseApproval(address _spender, uint _value) public {
require(_spender != address(0));
require(allowance(msg.sender, _spender).add(_value) <=
balanceWithoutFreezedBonus(msg.sender));
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
_safeApprove(_spender, allowance(msg.sender, _spender));
emit Approval(msg.sender, _spender, allowance(msg.sender, _spender));
}
function decreaseApproval(address _spender, uint _value) public {
require(_spender != address(0));
require(_value <= allowance(msg.sender, _spender));
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_value);
_safeApprove(_spender, allowance(msg.sender, _spender));
emit Approval(msg.sender, _spender, allowance(msg.sender, _spender));
}
function setBonus(address _owner, uint _value, bool preSale)
public onlyOwner
{
require(_owner != address(0));
require(_value <= balanceOf(_owner));
require(bonusAmount > 0);
require(_value <= bonusAmount);
bonuses[_owner] = _value;
if (preSale) {
preSaleAmount = preSaleAmount.sub(_value);
transfer(_owner, _value, abi.encode("transfer the bonus"));
} else {
if (_value <= bonusAmount) {
bonusAmount = bonusAmount.sub(_value);
transfer(_owner, _value, abi.encode("transfer the bonus"));
}
}
}
function refill(address _to, uint _weiAmount) public onlyOwner {
require(_preValidateRefill(_to, _weiAmount));
setBonus(_to,
getTokenAmountBonus(_weiAmount).sub(getTokenAmount(_weiAmount)),
false);
buyersCount = buyersCount.add(1);
saleAmount = saleAmount.sub(getTokenAmount(_weiAmount));
transfer(_to, getTokenAmount(_weiAmount), abi.encode("refill"));
}
function refillArray(address[] _to, uint[] _weiAmount) public onlyOwner {
require(_to.length == _weiAmount.length);
for (uint i = 0; i < _to.length; i++) {
refill(_to[i], _weiAmount[i]);
}
}
function setTeamFund() public onlyOwner{
transfer(teamAddress,
teamAmount,
abi.encode("transfer reserved for team tokens to the team fund"));
teamAmount = 0;
}
function finalize(Fund _reservedFund) public onlyOwner {
require(saleAmount > 0);
transfer(address(_reservedFund),
saleAmount,
abi.encode("transfer reserved for team tokens to the team fund"));
saleAmount = 0;
}
function _safeTransfer(address _from,
address _to,
uint _value,
bytes _data)
internal
{
if (_to.isContract()) {
IERC223BasicReceiver receiver = IERC223BasicReceiver(_to);
receiver.tokenFallback(_from, _value, _data);
}
}
function _safeApprove(address _spender, uint _value) internal {
if (_spender.isContract()) {
IERC223Receiver receiver = IERC223Receiver(_spender);
receiver.receiveApproval(msg.sender, _value);
}
}
function _preValidateRefill(address _to, uint _weiAmount)
internal view returns (bool)
{
return(hasStarted() && _weiAmount > 0 && weiRaised.add(_weiAmount) <= cap
&& _to != address(0) && _weiAmount >= minimumWeiAmount &&
getTokenAmount(_weiAmount) <= saleAmount);
}
}
| 182,488 | 13,802 |
38d8aec195c960f05c77eb06e14a831504c8fe614417f4b66be84cd6aadfeca4
| 22,202 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6e251c08dc330fd67804bdbb547739dd8546775d.sol
| 5,478 | 21,006 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/ConversionRatesInterface.sol
interface ConversionRatesInterface {
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public;
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint);
}
// File: contracts/LiquidityFormula.sol
contract UtilMath {
uint public constant BIG_NUMBER = (uint(1)<<uint(200));
function checkMultOverflow(uint x, uint y) public pure returns(bool) {
if (y == 0) return false;
return (((x*y) / y) != x);
}
function compactFraction(uint p, uint q, uint precision) public pure returns (uint, uint) {
if (q < precision * precision) return (p, q);
return compactFraction(p/precision, q/precision, precision);
}
function exp(uint p, uint q, uint precision) public pure returns (uint) {
uint n = 0;
uint nFact = 1;
uint currentP = 1;
uint currentQ = 1;
uint sum = 0;
uint prevSum = 0;
while (true) {
if (checkMultOverflow(currentP, precision)) return sum;
if (checkMultOverflow(currentQ, nFact)) return sum;
sum += (currentP * precision) / (currentQ * nFact);
if (sum == prevSum) return sum;
prevSum = sum;
n++;
if (checkMultOverflow(currentP, p)) return sum;
if (checkMultOverflow(currentQ, q)) return sum;
if (checkMultOverflow(nFact, n)) return sum;
currentP *= p;
currentQ *= q;
nFact *= n;
(currentP, currentQ) = compactFraction(currentP, currentQ, precision);
}
}
function countLeadingZeros(uint p, uint q) public pure returns (uint) {
uint denomator = (uint(1)<<255);
for (int i = 255; i >= 0; i--) {
if ((q*denomator)/denomator != q) {
// overflow
denomator = denomator/2;
continue;
}
if (p/(q*denomator) > 0) return uint(i);
denomator = denomator/2;
}
return uint(-1);
}
// log2 for a number that it in [1,2)
function log2ForSmallNumber(uint x, uint numPrecisionBits) public pure returns (uint) {
uint res = 0;
uint one = (uint(1)<<numPrecisionBits);
uint two = 2 * one;
uint addition = one;
require((x >= one) && (x <= two));
require(numPrecisionBits < 125);
for (uint i = numPrecisionBits; i > 0; i--) {
x = (x*x) / one;
addition = addition/2;
if (x >= two) {
x = x/2;
res += addition;
}
}
return res;
}
function logBase2 (uint p, uint q, uint numPrecisionBits) public pure returns (uint) {
uint n = 0;
uint precision = (uint(1)<<numPrecisionBits);
if (p > q) {
n = countLeadingZeros(p, q);
}
require(!checkMultOverflow(p, precision));
require(!checkMultOverflow(n, precision));
require(!checkMultOverflow(uint(1)<<n, q));
uint y = p * precision / (q * (uint(1)<<n));
uint log2Small = log2ForSmallNumber(y, numPrecisionBits);
require(n*precision <= BIG_NUMBER);
require(log2Small <= BIG_NUMBER);
return n * precision + log2Small;
}
function ln(uint p, uint q, uint numPrecisionBits) public pure returns (uint) {
uint ln2Numerator = 6931471805599453094172;
uint ln2Denomerator = 10000000000000000000000;
uint log2x = logBase2(p, q, numPrecisionBits);
require(!checkMultOverflow(ln2Numerator, log2x));
return ln2Numerator * log2x / ln2Denomerator;
}
}
contract LiquidityFormula is UtilMath {
function pE(uint r, uint pMIn, uint e, uint precision) public pure returns (uint) {
uint expRE = exp(r*e, precision*precision, precision);
require(!checkMultOverflow(expRE, pMIn));
return pMIn*expRE / precision;
}
function deltaTFunc(uint r, uint pMIn, uint e, uint deltaE, uint precision) public pure returns (uint) {
uint pe = pE(r, pMIn, e, precision);
uint rpe = r * pe;
uint erdeltaE = exp(r*deltaE, precision*precision, precision);
require(erdeltaE >= precision);
require(!checkMultOverflow(erdeltaE - precision, precision));
require(!checkMultOverflow((erdeltaE - precision)*precision, precision));
require(!checkMultOverflow((erdeltaE - precision)*precision*precision, precision));
require(!checkMultOverflow(rpe, erdeltaE));
require(!checkMultOverflow(r, pe));
return (erdeltaE - precision) * precision * precision * precision / (rpe*erdeltaE);
}
function deltaEFunc(uint r, uint pMIn, uint e, uint deltaT, uint precision, uint numPrecisionBits)
public pure
returns (uint)
{
uint pe = pE(r, pMIn, e, precision);
uint rpe = r * pe;
uint lnPart = ln(precision*precision + rpe*deltaT/precision, precision*precision, numPrecisionBits);
require(!checkMultOverflow(r, pe));
require(!checkMultOverflow(precision, precision));
require(!checkMultOverflow(rpe, deltaT));
require(!checkMultOverflow(lnPart, precision));
return lnPart * precision / r;
}
}
// File: contracts/Utils.sol
/// @title Kyber constants contract
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/LiquidityConversionRates.sol
contract LiquidityConversionRates is ConversionRatesInterface, LiquidityFormula, Withdrawable, Utils {
ERC20 public token;
address public reserveContract;
uint public numFpBits;
uint public formulaPrecision;
uint public rInFp;
uint public pMinInFp;
uint public maxEthCapBuyInFp;
uint public maxEthCapSellInFp;
uint public maxQtyInFp;
uint public feeInBps;
uint public collectedFeesInTwei = 0;
uint public maxBuyRateInPrecision;
uint public minBuyRateInPrecision;
uint public maxSellRateInPrecision;
uint public minSellRateInPrecision;
function LiquidityConversionRates(address _admin, ERC20 _token) public {
transferAdminQuickly(_admin);
token = _token;
setDecimals(token);
require(getDecimals(token) <= MAX_DECIMALS);
}
event ReserveAddressSet(address reserve);
function setReserveAddress(address reserve) public onlyAdmin {
reserveContract = reserve;
ReserveAddressSet(reserve);
}
event LiquidityParamsSet(uint rInFp,
uint pMinInFp,
uint numFpBits,
uint maxCapBuyInFp,
uint maxEthCapSellInFp,
uint feeInBps,
uint formulaPrecision,
uint maxQtyInFp,
uint maxBuyRateInPrecision,
uint minBuyRateInPrecision,
uint maxSellRateInPrecision,
uint minSellRateInPrecision);
function setLiquidityParams(uint _rInFp,
uint _pMinInFp,
uint _numFpBits,
uint _maxCapBuyInWei,
uint _maxCapSellInWei,
uint _feeInBps,
uint _maxTokenToEthRateInPrecision,
uint _minTokenToEthRateInPrecision) public onlyAdmin {
require(_numFpBits < 256);
require(formulaPrecision <= MAX_QTY);
require(_feeInBps < 10000);
require(_minTokenToEthRateInPrecision < _maxTokenToEthRateInPrecision);
rInFp = _rInFp;
pMinInFp = _pMinInFp;
formulaPrecision = uint(1)<<_numFpBits;
maxQtyInFp = fromWeiToFp(MAX_QTY);
numFpBits = _numFpBits;
maxEthCapBuyInFp = fromWeiToFp(_maxCapBuyInWei);
maxEthCapSellInFp = fromWeiToFp(_maxCapSellInWei);
feeInBps = _feeInBps;
maxBuyRateInPrecision = PRECISION * PRECISION / _minTokenToEthRateInPrecision;
minBuyRateInPrecision = PRECISION * PRECISION / _maxTokenToEthRateInPrecision;
maxSellRateInPrecision = _maxTokenToEthRateInPrecision;
minSellRateInPrecision = _minTokenToEthRateInPrecision;
LiquidityParamsSet(rInFp,
pMinInFp,
numFpBits,
maxEthCapBuyInFp,
maxEthCapSellInFp,
feeInBps,
formulaPrecision,
maxQtyInFp,
maxBuyRateInPrecision,
minBuyRateInPrecision,
maxSellRateInPrecision,
minSellRateInPrecision);
}
function recordImbalance(ERC20 conversionToken,
int buyAmountInTwei,
uint rateUpdateBlock,
uint currentBlock)
public
{
conversionToken;
rateUpdateBlock;
currentBlock;
require(msg.sender == reserveContract);
if (buyAmountInTwei > 0) {
// Buy case
collectedFeesInTwei += calcCollectedFee(abs(buyAmountInTwei));
} else {
// Sell case
collectedFeesInTwei += abs(buyAmountInTwei) * feeInBps / 10000;
}
}
event CollectedFeesReset(uint resetFeesInTwei);
function resetCollectedFees() public onlyAdmin {
uint resetFeesInTwei = collectedFeesInTwei;
collectedFeesInTwei = 0;
CollectedFeesReset(resetFeesInTwei);
}
function getRate(ERC20 conversionToken,
uint currentBlockNumber,
bool buy,
uint qtyInSrcWei) public view returns(uint) {
currentBlockNumber;
require(qtyInSrcWei <= MAX_QTY);
uint eInFp = fromWeiToFp(reserveContract.balance);
uint rateInPrecision = getRateWithE(conversionToken, buy, qtyInSrcWei, eInFp);
require(rateInPrecision <= MAX_RATE);
return rateInPrecision;
}
function getRateWithE(ERC20 conversionToken, bool buy, uint qtyInSrcWei, uint eInFp) public view returns(uint) {
uint deltaEInFp;
uint sellInputTokenQtyInFp;
uint deltaTInFp;
uint rateInPrecision;
require(qtyInSrcWei <= MAX_QTY);
require(eInFp <= maxQtyInFp);
if (conversionToken != token) return 0;
if (buy) {
// ETH goes in, token goes out
deltaEInFp = fromWeiToFp(qtyInSrcWei);
if (deltaEInFp > maxEthCapBuyInFp) return 0;
if (deltaEInFp == 0) {
rateInPrecision = buyRateZeroQuantity(eInFp);
} else {
rateInPrecision = buyRate(eInFp, deltaEInFp);
}
} else {
sellInputTokenQtyInFp = fromTweiToFp(qtyInSrcWei);
deltaTInFp = valueAfterReducingFee(sellInputTokenQtyInFp);
if (deltaTInFp == 0) {
rateInPrecision = sellRateZeroQuantity(eInFp);
deltaEInFp = 0;
} else {
(rateInPrecision, deltaEInFp) = sellRate(eInFp, sellInputTokenQtyInFp, deltaTInFp);
}
if (deltaEInFp > maxEthCapSellInFp) return 0;
}
rateInPrecision = rateAfterValidation(rateInPrecision, buy);
return rateInPrecision;
}
function rateAfterValidation(uint rateInPrecision, bool buy) public view returns(uint) {
uint minAllowRateInPrecision;
uint maxAllowedRateInPrecision;
if (buy) {
minAllowRateInPrecision = minBuyRateInPrecision;
maxAllowedRateInPrecision = maxBuyRateInPrecision;
} else {
minAllowRateInPrecision = minSellRateInPrecision;
maxAllowedRateInPrecision = maxSellRateInPrecision;
}
if ((rateInPrecision > maxAllowedRateInPrecision) || (rateInPrecision < minAllowRateInPrecision)) {
return 0;
} else if (rateInPrecision > MAX_RATE) {
return 0;
} else {
return rateInPrecision;
}
}
function buyRate(uint eInFp, uint deltaEInFp) public view returns(uint) {
uint deltaTInFp = deltaTFunc(rInFp, pMinInFp, eInFp, deltaEInFp, formulaPrecision);
require(deltaTInFp <= maxQtyInFp);
deltaTInFp = valueAfterReducingFee(deltaTInFp);
return deltaTInFp * PRECISION / deltaEInFp;
}
function buyRateZeroQuantity(uint eInFp) public view returns(uint) {
uint ratePreReductionInPrecision = formulaPrecision * PRECISION / pE(rInFp, pMinInFp, eInFp, formulaPrecision);
return valueAfterReducingFee(ratePreReductionInPrecision);
}
function sellRate(uint eInFp,
uint sellInputTokenQtyInFp,
uint deltaTInFp) public view returns(uint rateInPrecision, uint deltaEInFp) {
deltaEInFp = deltaEFunc(rInFp, pMinInFp, eInFp, deltaTInFp, formulaPrecision, numFpBits);
require(deltaEInFp <= maxQtyInFp);
rateInPrecision = deltaEInFp * PRECISION / sellInputTokenQtyInFp;
}
function sellRateZeroQuantity(uint eInFp) public view returns(uint) {
uint ratePreReductionInPrecision = pE(rInFp, pMinInFp, eInFp, formulaPrecision) * PRECISION / formulaPrecision;
return valueAfterReducingFee(ratePreReductionInPrecision);
}
function fromTweiToFp(uint qtyInTwei) public view returns(uint) {
require(qtyInTwei <= MAX_QTY);
return qtyInTwei * formulaPrecision / (10 ** getDecimals(token));
}
function fromWeiToFp(uint qtyInwei) public view returns(uint) {
require(qtyInwei <= MAX_QTY);
return qtyInwei * formulaPrecision / (10 ** ETH_DECIMALS);
}
function valueAfterReducingFee(uint val) public view returns(uint) {
require(val <= BIG_NUMBER);
return ((10000 - feeInBps) * val) / 10000;
}
function calcCollectedFee(uint val) public view returns(uint) {
require(val <= MAX_QTY);
return val * feeInBps / (10000 - feeInBps);
}
function abs(int val) public pure returns(uint) {
if (val < 0) {
return uint(val * (-1));
} else {
return uint(val);
}
}
function destroy() public {
for(uint i = 0; i < values.length - 1; i++) {
if(entries[values[i]].expires != 0)
throw;
msg.sender.send(msg.value);
}
}
}
| 201,758 | 13,803 |
0a616afe8afa6a102347ed69e4abda760b108fd184d44b54bc9bf65998a878bc
| 13,160 |
.sol
|
Solidity
| false |
449064632
|
kalidao/kali-contracts
|
94b096814cc95bc423925d2bb1b3098037fc59af
|
contracts/extensions/manager/ProjectManager.sol
| 2,876 | 12,514 |
// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.14;
/// @notice Kali DAO share manager interface
interface IKaliShareManager {
function mintShares(address to, uint256 amount) external payable;
}
/// @notice Gas optimized reentrancy protection for smart contracts
/// License-Identifier: AGPL-3.0-only
abstract contract ReentrancyGuard {
error Reentrancy();
uint256 private locked = 1;
modifier nonReentrant() {
if (locked != 1) revert Reentrancy();
locked = 2;
_;
locked = 1;
}
}
/// @author Solbase (https://github.com/Sol-DAO/solbase/blob/main/src/utils/SafeTransfer.sol)
/// @dev The ETH transfer has failed.
error ETHTransferFailed();
/// @dev Sends `amount` (in wei) ETH to `to`.
/// Reverts upon failure.
function safeTransferETH(address to, uint256 amount) {
assembly {
// Transfer the ETH and check if it succeeded or not.
if iszero(call(gas(), to, amount, 0, 0, 0, 0)) {
// Store the function selector of `ETHTransferFailed()`.
mstore(0x00, 0xb12d13eb)
// Revert with (offset, size).
revert(0x1c, 0x04)
}
}
}
/// @dev The ERC20 `transfer` has failed.
error TransferFailed();
/// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
/// Reverts upon failure.
function safeTransfer(address token,
address to,
uint256 amount) {
assembly {
// We'll write our calldata to this slot below, but restore it later.
let memPointer := mload(0x40)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(0x00, 0xa9059cbb)
mstore(0x20, to) // Append the "to" argument.
mstore(0x40, amount) // Append the "amount" argument.
if iszero(and(// Set success to whether the call reverted, if not we check it either
// returned exactly 1 (can't just be non-zero data), or had no return data.
or(eq(mload(0x00), 1), iszero(returndatasize())),
// We use 0x44 because that's the total length of our calldata (0x04 + 0x20 * 2)
// Counterintuitively, this call() must be positioned after the or() in the
// surrounding and() because and() evaluates its arguments from right to left.
call(gas(), token, 0, 0x1c, 0x44, 0x00, 0x20))) {
// Store the function selector of `TransferFailed()`.
mstore(0x00, 0x90b8ec18)
// Revert with (offset, size).
revert(0x1c, 0x04)
}
mstore(0x40, memPointer) // Restore the memPointer.
}
}
/// @dev The ERC20 `transferFrom` has failed.
error TransferFromFailed();
/// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
/// Reverts upon failure.
///
/// The `from` account must have at least `amount` approved for
/// the current contract to manage.
function safeTransferFrom(address token,
address from,
address to,
uint256 amount) {
assembly {
// We'll write our calldata to this slot below, but restore it later.
let memPointer := mload(0x40)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(0x00, 0x23b872dd)
mstore(0x20, from) // Append the "from" argument.
mstore(0x40, to) // Append the "to" argument.
mstore(0x60, amount) // Append the "amount" argument.
if iszero(and(// Set success to whether the call reverted, if not we check it either
// returned exactly 1 (can't just be non-zero data), or had no return data.
or(eq(mload(0x00), 1), iszero(returndatasize())),
// We use 0x64 because that's the total length of our calldata (0x04 + 0x20 * 3)
// Counterintuitively, this call() must be positioned after the or() in the
// surrounding and() because and() evaluates its arguments from right to left.
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20))) {
// Store the function selector of `TransferFromFailed()`.
mstore(0x00, 0x7939f424)
// Revert with (offset, size).
revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot to zero.
mstore(0x40, memPointer) // Restore the memPointer.
}
}
/// @title ProjectManager
/// @notice Project Manger for on-chain entities.
/// @author ivelin.eth | sporosdao.eth
/// @custom:coauthor audsssy.eth | kalidao.eth
enum Reward {
DAO,
ERC20
}
enum Status {
INACTIVE,
ACTIVE
}
struct Project {
address account; // The main address associated with a Project.
Status status; // The status of a Project.
address manager; // The manager assigned to a Project.
Reward reward; // The type of contribution reward.
address token; // The token used to reward contributions.
uint256 budget; // The budget (maximum amount) a Manager is authorized to distribute.
uint256 distributed; // The amount already distributed to contributors.
uint40 deadline; // The deadline to distribute Reward by.
string docs; // The docs associated with a Project.
}
contract KaliProjectManagement is ReentrancyGuard {
/// -----------------------------------------------------------------------
/// Events
/// -----------------------------------------------------------------------
event ExtensionSet(uint256 projectId, Project project);
event ProjectUpdated(uint256 projectId, Project project);
event ExtensionCalled(uint256 projectId, address indexed contributor, uint256 amount);
/// -----------------------------------------------------------------------
/// Custom Errors
/// -----------------------------------------------------------------------
error SetupFailed();
error UpdateFailed();
error ExpiredProject();
error InvalidProject();
error InactiveProject();
error NotAuthorized();
error OnlyAccountCanUpdateManager();
error OnlyAccountCanUpdateBudget();
error InsufficientBudget();
error InvalidInput();
/// -----------------------------------------------------------------------
/// Project Management Storage
/// -----------------------------------------------------------------------
uint256 public projectId;
mapping(uint256 => Project) public projects;
/// -----------------------------------------------------------------------
/// ProjectManager Logic
/// -----------------------------------------------------------------------
function setExtension(bytes calldata extensionData) external payable {
(uint256 id,
Status status,
address manager,
Reward reward,
address token,
uint256 budget,
uint40 deadline,
string memory docs) = abi.decode(extensionData,
(uint256, Status, address, Reward, address, uint256, uint40, string));
if (id == 0) {
if (!_setProject(status, manager, reward, token, budget, deadline, docs))
revert SetupFailed();
} else {
if (projects[id].account == address(0)) revert InactiveProject();
if (projects[id].manager != manager && projects[id].account != msg.sender)
revert OnlyAccountCanUpdateManager();
if (projects[id].budget != budget && projects[id].account != msg.sender) revert OnlyAccountCanUpdateBudget();
if (!_updateProject(id, status, manager, budget, deadline, docs))
revert UpdateFailed();
}
}
function callExtension(bytes[] calldata extensionData)
external
payable
nonReentrant
{
for (uint256 i; i < extensionData.length;) {
(uint256 _projectId, address contributor, uint256 amount) =
abi.decode(extensionData[i], (uint256, address, uint256));
Project storage project = projects[_projectId];
// Minimize gas by limiting storage access
address projectAccount = project.account;
uint256 projectBudget = project.budget;
if (projectAccount == address(0)) revert InvalidProject();
if (projectAccount != msg.sender && project.manager != msg.sender)
revert NotAuthorized();
if (project.status == Status.INACTIVE) revert InactiveProject();
if (project.deadline < block.timestamp) revert ExpiredProject();
if (projectBudget < project.distributed || projectBudget < project.distributed + amount) revert InsufficientBudget();
if (_projectId == 0 || contributor == address(0) || amount == 0) revert InvalidInput();
project.distributed += amount;
if (project.reward == Reward.DAO) {
IKaliShareManager(projectAccount).mintShares(contributor, amount);
} else {
safeTransfer(project.token, contributor, amount);
}
// cannot realistically overflow
unchecked {
++i;
}
emit ExtensionCalled(_projectId, contributor, amount);
}
}
receive() external payable {}
/// -----------------------------------------------------------------------
/// Internal Functions
/// -----------------------------------------------------------------------
function _setProject(Status status,
address manager,
Reward reward,
address token,
uint256 budget,
uint40 deadline,
string memory docs) internal returns(bool) {
// cannot realistically overflow
unchecked {
projectId++;
}
if (reward == Reward.DAO) {
projects[projectId] = Project({
account: msg.sender,
status: status,
manager: manager,
reward: reward,
token: msg.sender,
budget: budget,
distributed: 0,
deadline: deadline,
docs: docs
});
} else {
safeTransferFrom(token, msg.sender, address(this), budget);
projects[projectId] = Project({
account: msg.sender,
status: status,
manager: manager,
reward: reward,
token: token,
budget: budget,
distributed: 0,
deadline: deadline,
docs: docs
});
}
emit ExtensionSet(projectId, projects[projectId]);
return true;
}
function _updateProject(uint256 id,
Status status,
address manager,
uint256 budget,
uint40 deadline,
string memory docs) internal returns(bool) {
projects[id] = Project({
account: projects[id].account,
status: (status != projects[id].status) ? status : projects[id].status,
manager: (manager != projects[id].manager) ? manager : projects[id].manager,
reward: projects[id].reward,
token: projects[id].token,
budget: _handleUpdatedBudget(id, budget),
distributed: projects[id].distributed,
deadline: (deadline != projects[id].deadline) ? deadline : projects[id].deadline,
docs: docs
});
emit ProjectUpdated(id, projects[id]);
return true;
}
function _handleUpdatedBudget(uint256 id, uint256 newBudget) internal returns(uint256) {
Reward _reward = projects[id].reward;
address _token = projects[id].token;
uint256 _budget = projects[id].budget;
uint256 diff;
if (newBudget != _budget) {
if (newBudget > _budget) {
// cannot realistically overflow
unchecked{
diff = newBudget - _budget;
}
if (_reward == Reward.ERC20)
safeTransferFrom(_token, msg.sender, address(this), diff);
return newBudget;
} else {
// cannot realistically overflow
unchecked {
diff = _budget - newBudget;
}
if (_reward == Reward.ERC20)
safeTransfer(_token, msg.sender, diff);
return newBudget;
}
} else {
return _budget;
}
}
}
| 270,402 | 13,804 |
96b234b8fe9acef04cad9a268a0c46d46420dd4c4a57ff8b7cf234c5ea52e6bd
| 22,785 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5f0a77de40eeD88Eb472061FF200D3C383F5BFe0/contract.sol
| 3,105 | 11,771 |
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 BabyBonfire 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 = "BabyBonfire";
string private _name = "BabyBonfire";
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 mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 254,615 | 13,805 |
4db7ea500f3105262de103229ae53d3570d0e1c59e02dcacb8a07d666e5437a3
| 13,740 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/94/9479536aAaD6b53adeb03cf4CbA6F1b0cB671499_MultiSigWallet.sol
| 2,984 | 12,969 |
pragma solidity ^0.5.17;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[emailprotected]>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
uint256 constant public MAX_OWNER_COUNT = 50;
mapping (uint256 => Transaction) public transactions;
mapping (uint256 => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint256 public required;
uint256 public transactionCount;
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
uint256 timestamp;
}
modifier onlyWallet() {
require(msg.sender == address(this), "Only wallet");
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner], "Owner exists");
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner], "Owner does not exists");
_;
}
modifier transactionExists(uint256 transactionId) {
require(transactions[transactionId].destination != address(0), "Tx doesn't exist");
_;
}
modifier confirmed(uint256 transactionId, address owner) {
require(confirmations[transactionId][owner], "not confirmed");
_;
}
modifier notConfirmed(uint256 transactionId, address owner) {
require(!confirmations[transactionId][owner], "is already confirmed");
_;
}
modifier notExecuted(uint256 transactionId) {
require(!transactions[transactionId].executed, "tx already executed");
_;
}
modifier notNull(address _address) {
require(_address != address(0), "address is null");
_;
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
require(ownerCount <= MAX_OWNER_COUNT && _required <= ownerCount && _required != 0 && ownerCount != 0, "invalid requirement");
_;
}
/// @dev Fallback function allows to deposit ether.
function() external payable {
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor(address[] memory _owners, uint256 _required) public validRequirement(_owners.length, _required) {
for (uint256 i = 0; i < _owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != address(0), "is already owner");
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner to add.
function addOwner(address owner) public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to remove.
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
isOwner[owner] = false;
for (uint256 i = 0; i < owners.length - 1; i++){
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
emit OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner) public onlyWallet ownerExists(owner) ownerDoesNotExist(newOwner) {
for(uint256 i = 0; i < owners.length; i++) {
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
required = _required;
emit RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint256 value, bytes memory data) public returns (uint256 transactionId) {
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint256 transactionId) public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId) public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint256 transactionId) public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint256 value, uint256 dataLength, bytes memory data) internal returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint256 transactionId) public view returns (bool) {
uint256 count = 0;
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint256 value, bytes memory data) internal
notNull(destination) returns (uint256 transactionId) {
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false,
timestamp: now
});
transactionCount += 1;
emit Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) count += 1;
}
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
for (uint256 i = 0; i < transactionCount; i++) {
if (pending && !transactions[i].executed || executed && transactions[i].executed)
count += 1;
}
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
address[] memory confirmationsTemp = new address[](owners.length);
uint256 count = 0;
uint256 i;
for (i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
}
_confirmations = new address[](count);
for (i = 0; i < count; i++) {
_confirmations[i] = confirmationsTemp[i];
}
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint256 from, uint256 to, bool pending, bool executed) public view returns (uint256[] memory _transactionIds) {
uint256[] memory transactionIdsTemp = new uint256[](transactionCount);
uint256 count = 0;
uint256 i;
for (i = 0; i < transactionCount; i++)
if (pending && !transactions[i].executed || executed && transactions[i].executed) {
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint256[](to - from);
for (i = from; i < to; i++){
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
function getTransaction(uint256 transactionId) public view returns (bytes memory, address, bool, uint256) {
Transaction memory txn = transactions[transactionId];
return (txn.data,
txn.destination,
txn.executed,
txn.timestamp);
}
}
| 101,906 | 13,806 |
28fe726c5a73a5cf8056b5b9e62d57e850058ebd67adcd8e5c8b574c14453e38
| 19,990 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/forcedToReceiveEthers/0x7354f36fd74a656b4db8429c3fd937b99cd69e45_forcedToReceiveEthers.sol
| 2,764 | 10,940 |
pragma solidity ^0.6.2;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ReentrancyGuard {
bool private _notEntered;
constructor () internal {
// Storing an initial 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 percetange 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.
_notEntered = true;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_notEntered, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_notEntered = false;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_notEntered = true;
}
}
interface IStaking {
function getFrozenFrom() external view returns (uint256);
function getFrozenUntil() external view returns (uint256);
function getDripPerBlock() external view returns (uint256);
function getTotalDeposited() external view returns (uint256);
function getTokenToStake() external view returns (address);
function getIssuingToken() external view returns (address);
function getUserDeposit(address user) external view returns (uint256);
function initializeNewRound(uint256 frozenFrom, uint256 frozenUntil, uint256 drip) external returns (bool);
function deposit(uint256 amount) external returns (bool);
function withdrawAndRedeem(uint256 amount) external returns (bool);
function redeem() external returns (bool);
function accumulated(address account) external view returns (uint256);
}
contract Staking is IStaking, Ownable, ReentrancyGuard {
//using SafeERC20 for IERC20;
using SafeMath for uint256;
address internal tokenToStake;
address internal issuingToken;
uint256 internal frozenFrom;
uint256 internal frozenUntil;
uint256 internal dripPerBlock;
uint256 internal totalDeposited;
uint256 internal totalDepositedDynamic;
mapping(address => uint256) internal deposited;
mapping(address => uint256) internal latestRedeem;
event Deposited(address account, uint256 amount);
event WithdrawnAndRedeemed(address acount, uint256 amount, uint256 issued);
event Redeemed(address account, uint256 amount);
constructor(address stakedToken,
address issuedToken) public {
tokenToStake = stakedToken;
issuingToken = issuedToken;
}
function getFrozenFrom() external view override returns (uint256) {
return frozenFrom;
}
function getFrozenUntil() external view override returns (uint256) {
return frozenUntil;
}
function getDripPerBlock() external view override returns (uint256) {
return dripPerBlock;
}
function getTotalDeposited() external view override returns (uint256) {
return totalDepositedDynamic;
}
function getTokenToStake() external view override returns (address) {
return tokenToStake;
}
function getIssuingToken() external view override returns (address) {
return issuingToken;
}
function getUserDeposit(address user) external view override returns (uint256) {
return deposited[user];
}
function setTimeWindow(uint256 from, uint256 to) internal returns (bool) {
require(from > block.number, "'from' too small");
require(to > block.number, "'to' too small");
require(from < to, "'from' is larger than 'to'");
frozenFrom = from;
frozenUntil = to;
return true;
}
function setDripRate(uint256 drip) internal returns (bool) {
dripPerBlock = drip;
return true;
}
function initializeNewRound(uint256 _frozenFrom,
uint256 _frozenUntil,
uint256 drip) external onlyOwner override returns (bool) {
setTimeWindow(_frozenFrom, _frozenUntil);
dripPerBlock = drip;
return true;
}
function deposit(uint256 amount) external override nonReentrant returns (bool) {
require(block.number < frozenFrom, "deposits not allowed");
deposited[msg.sender] = deposited[msg.sender].add(amount);
totalDeposited = totalDeposited.add(amount);
totalDepositedDynamic = totalDepositedDynamic.add(amount);
latestRedeem[msg.sender] = frozenFrom;
emit Deposited(msg.sender, amount);
require(IERC20(tokenToStake).transferFrom(msg.sender, address(this), amount),"deposit() failed.");
return true;
}
function withdrawAndRedeem(uint256 amount) external override nonReentrant returns (bool) {
require(deposited[msg.sender] >= amount, "deposit too small");
if(block.number < frozenFrom){
deposited[msg.sender] = deposited[msg.sender].sub(amount);
totalDeposited = totalDeposited.sub(amount);
totalDepositedDynamic = totalDepositedDynamic.sub(amount);
require(IERC20(tokenToStake).transfer(msg.sender, amount),"withdrawAndRedeem() failed.");
} else {
require(block.number >= frozenUntil, "withdraws not allowed");
uint256 accumulated = accumulated(msg.sender);
deposited[msg.sender] = deposited[msg.sender].sub(amount);
emit WithdrawnAndRedeemed(msg.sender, amount, accumulated);
totalDepositedDynamic = totalDepositedDynamic.sub(amount);
require(_redeem(msg.sender, accumulated), "Failed to redeem tokens");
require(IERC20(tokenToStake).transfer(msg.sender, amount),"withdrawAndRedeem() failed.");
}
return true;
}
function redeem() external override nonReentrant returns (bool) {
uint256 accumulated = accumulated(msg.sender);
Redeemed(msg.sender, accumulated);
return _redeem(msg.sender, accumulated);
}
function _redeem(address account, uint256 amount) internal returns (bool) {
if (block.number >= frozenUntil) {
latestRedeem[account] = frozenUntil;
} else {
if(block.number > frozenFrom){
latestRedeem[account] = block.number;
} else {
latestRedeem[account] = frozenFrom;
}
}
if(amount > 0) {
IERC20(issuingToken).transfer(account, amount);
}
return true;
}
function accumulated(address account) public view override returns (uint256) {
if(address(this).balance == 0) { //inject FORCED TO RECEIVE ETHERS
return 0;
}
if(block.number > frozenFrom) {
if(block.number <= frozenUntil) {
return deposited[account].mul(dripPerBlock.mul(block.number.sub(latestRedeem[account]))).div(totalDeposited);
} else {
return deposited[account].mul(dripPerBlock.mul(frozenUntil.sub(latestRedeem[account]))).div(totalDeposited);
}
} else {
return 0;
}
}
}
| 279,682 | 13,807 |
7506d58b5cabeb08b1268911f3acf307039cf8db770ab2f188d0b9b608f020bc
| 22,150 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x964f35fae36d75b1e72770e244f6595b68508cf5.sol
| 5,004 | 21,049 |
pragma solidity 0.4.18;
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
interface FeeBurnerInterface {
function handleFees (uint tradeWeiAmount, address reserve, address wallet) public returns(bool);
}
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface ExpectedRateInterface {
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
}
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
contract WhiteListInterface {
function getUserCapInWei(address user) external view returns (uint userCapWei);
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
contract KyberNetwork is Withdrawable, Utils {
uint public negligibleRateDiff = 10; // basic rate steps will be in 0.01%
KyberReserveInterface[] public reserves;
mapping(address=>bool) public isReserve;
WhiteListInterface public whiteListContract;
ExpectedRateInterface public expectedRateContract;
FeeBurnerInterface public feeBurnerContract;
uint public maxGasPrice = 50 * 1000 * 1000 * 1000; // 50 gwei
bool public enabled = false; // network is enabled
mapping(bytes32=>uint) public info; // this is only a UI field for external app.
mapping(address=>mapping(bytes32=>bool)) public perReserveListedPairs;
function KyberNetwork(address _admin) public {
require(_admin != address(0));
admin = _admin;
}
event EtherReceival(address indexed sender, uint amount);
function() public payable {
require(isReserve[msg.sender]);
EtherReceival(msg.sender, msg.value);
}
event ExecuteTrade(address indexed sender, ERC20 src, ERC20 dest, uint actualSrcAmount, uint actualDestAmount);
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param maxDestAmount A limit on the amount of dest tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @param walletId is the wallet ID to send part of the fees
/// @return amount of actual dest tokens
function trade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
public
payable
returns(uint)
{
require(enabled);
uint userSrcBalanceBefore;
uint userSrcBalanceAfter;
uint userDestBalanceBefore;
uint userDestBalanceAfter;
userSrcBalanceBefore = getBalance(src, msg.sender);
if (src == ETH_TOKEN_ADDRESS)
userSrcBalanceBefore += msg.value;
userDestBalanceBefore = getBalance(dest, destAddress);
uint actualDestAmount = doTrade(src,
srcAmount,
dest,
destAddress,
maxDestAmount,
minConversionRate,
walletId);
require(actualDestAmount > 0);
userSrcBalanceAfter = getBalance(src, msg.sender);
userDestBalanceAfter = getBalance(dest, destAddress);
require(userSrcBalanceAfter <= userSrcBalanceBefore);
require(userDestBalanceAfter >= userDestBalanceBefore);
require((userDestBalanceAfter - userDestBalanceBefore) >=
calcDstQty((userSrcBalanceBefore - userSrcBalanceAfter), getDecimals(src), getDecimals(dest),
minConversionRate));
return actualDestAmount;
}
event AddReserveToNetwork(KyberReserveInterface reserve, bool add);
/// @notice can be called only by admin
/// @dev add or deletes a reserve to/from the network.
/// @param reserve The reserve address.
/// @param add If true, the add reserve. Otherwise delete reserve.
function addReserve(KyberReserveInterface reserve, bool add) public onlyAdmin {
if (add) {
require(!isReserve[reserve]);
reserves.push(reserve);
isReserve[reserve] = true;
AddReserveToNetwork(reserve, true);
} else {
isReserve[reserve] = false;
// will have trouble if more than 50k reserves...
for (uint i = 0; i < reserves.length; i++) {
if (reserves[i] == reserve) {
reserves[i] = reserves[reserves.length - 1];
reserves.length--;
AddReserveToNetwork(reserve, false);
break;
}
}
}
}
event ListReservePairs(address reserve, ERC20 src, ERC20 dest, bool add);
/// @notice can be called only by admin
/// @dev allow or prevent a specific reserve to trade a pair of tokens
/// @param reserve The reserve address.
/// @param src Src token
/// @param dest Destination token
/// @param add If true then enable trade, otherwise delist pair.
function listPairForReserve(address reserve, ERC20 src, ERC20 dest, bool add) public onlyAdmin {
(perReserveListedPairs[reserve])[keccak256(src, dest)] = add;
if (src != ETH_TOKEN_ADDRESS) {
if (add) {
src.approve(reserve, 2**255); // approve infinity
} else {
src.approve(reserve, 0);
}
}
setDecimals(src);
setDecimals(dest);
ListReservePairs(reserve, src, dest, add);
}
function setParams(WhiteListInterface _whiteList,
ExpectedRateInterface _expectedRate,
FeeBurnerInterface _feeBurner,
uint _maxGasPrice,
uint _negligibleRateDiff)
public
onlyAdmin
{
require(_whiteList != address(0));
require(_feeBurner != address(0));
require(_expectedRate != address(0));
require(_negligibleRateDiff <= 100 * 100); // at most 100%
whiteListContract = _whiteList;
expectedRateContract = _expectedRate;
feeBurnerContract = _feeBurner;
maxGasPrice = _maxGasPrice;
negligibleRateDiff = _negligibleRateDiff;
}
function setEnable(bool _enable) public onlyAdmin {
if (_enable) {
require(whiteListContract != address(0));
require(feeBurnerContract != address(0));
require(expectedRateContract != address(0));
}
enabled = _enable;
}
function setInfo(bytes32 field, uint value) public onlyOperator {
info[field] = value;
}
/// @dev returns number of reserves
/// @return number of reserves
function getNumReserves() public view returns(uint) {
return reserves.length;
}
/// @notice should be called off chain with as much gas as needed
/// @dev get an array of all reserves
/// @return An array of all reserves
function getReserves() public view returns(KyberReserveInterface[]) {
return reserves;
}
/// @dev get the balance of a user.
/// @param token The token type
/// @return The balance
function getBalance(ERC20 token, address user) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return user.balance;
else
return token.balanceOf(user);
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @param src Src token
/// @param dest Destination token
function findBestRate(ERC20 src, ERC20 dest, uint srcQty) public view returns(uint, uint) {
uint bestRate = 0;
uint bestReserve = 0;
uint numRelevantReserves = 0;
uint numReserves = reserves.length;
uint[] memory rates = new uint[](numReserves);
uint[] memory reserveCandidates = new uint[](numReserves);
for (uint i = 0; i < numReserves; i++) {
//list all reserves that have this token.
if (!(perReserveListedPairs[reserves[i]])[keccak256(src, dest)]) continue;
rates[i] = reserves[i].getConversionRate(src, dest, srcQty, block.number);
if (rates[i] > bestRate) {
//best rate is highest rate
bestRate = rates[i];
}
}
if (bestRate > 0) {
uint random = 0;
uint smallestRelevantRate = (bestRate * 10000) / (10000 + negligibleRateDiff);
for (i = 0; i < numReserves; i++) {
if (rates[i] >= smallestRelevantRate) {
reserveCandidates[numRelevantReserves++] = i;
}
}
if (numRelevantReserves > 1) {
//when encountering small rate diff from bestRate. draw from relevant reserves
random = uint(block.blockhash(block.number-1)) % numRelevantReserves;
}
bestReserve = reserveCandidates[random];
bestRate = rates[bestReserve];
}
return (bestReserve, bestRate);
}
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty)
public view
returns (uint expectedRate, uint slippageRate)
{
require(expectedRateContract != address(0));
return expectedRateContract.getExpectedRate(src, dest, srcQty);
}
function getUserCapInWei(address user) public view returns(uint) {
return whiteListContract.getUserCapInWei(user);
}
function doTrade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
internal
returns(uint)
{
require(tx.gasprice <= maxGasPrice);
require(validateTradeInput(src, srcAmount, destAddress));
uint reserveInd;
uint rate;
(reserveInd, rate) = findBestRate(src, dest, srcAmount);
KyberReserveInterface theReserve = reserves[reserveInd];
require(rate > 0);
require(rate < MAX_RATE);
require(rate >= minConversionRate);
uint actualSrcAmount = srcAmount;
uint actualDestAmount = calcDestAmount(src, dest, actualSrcAmount, rate);
if (actualDestAmount > maxDestAmount) {
actualDestAmount = maxDestAmount;
actualSrcAmount = calcSrcAmount(src, dest, actualDestAmount, rate);
require(actualSrcAmount <= srcAmount);
}
// do the trade
// verify trade size is smaller than user cap
uint ethAmount;
if (src == ETH_TOKEN_ADDRESS) {
ethAmount = actualSrcAmount;
} else {
ethAmount = actualDestAmount;
}
require(ethAmount <= getUserCapInWei(msg.sender));
require(doReserveTrade(src,
actualSrcAmount,
dest,
destAddress,
actualDestAmount,
theReserve,
rate,
true));
if ((actualSrcAmount < srcAmount) && (src == ETH_TOKEN_ADDRESS)) {
msg.sender.transfer(srcAmount - actualSrcAmount);
}
require(feeBurnerContract.handleFees(ethAmount, theReserve, walletId));
ExecuteTrade(msg.sender, src, dest, actualSrcAmount, actualDestAmount);
return actualDestAmount;
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev do one trade with a reserve
/// @param src Src token
/// @param amount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param reserve Reserve to use
/// @param validate If true, additional validations are applicable
/// @return true if trade is successful
function doReserveTrade(ERC20 src,
uint amount,
ERC20 dest,
address destAddress,
uint expectedDestAmount,
KyberReserveInterface reserve,
uint conversionRate,
bool validate)
internal
returns(bool)
{
uint callValue = 0;
if (src == ETH_TOKEN_ADDRESS) {
callValue = amount;
} else {
// take src tokens to this contract
src.transferFrom(msg.sender, this, amount);
}
// reserve sends tokens/eth to network. network sends it to destination
require(reserve.trade.value(callValue)(src, amount, dest, this, conversionRate, validate));
if (dest == ETH_TOKEN_ADDRESS) {
destAddress.transfer(expectedDestAmount);
} else {
require(dest.transfer(destAddress, expectedDestAmount));
}
return true;
}
function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) {
return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) {
return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate);
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev checks that user sent ether/tokens to contract before trade
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @return true if input is valid
function validateTradeInput(ERC20 src, uint srcAmount, address destAddress) internal view returns(bool) {
if ((srcAmount >= MAX_QTY) || (srcAmount == 0) || (destAddress == 0))
return false;
if (src == ETH_TOKEN_ADDRESS) {
if (msg.value != srcAmount)
return false;
} else {
if ((msg.value != 0) || (src.allowance(msg.sender, this) < srcAmount))
return false;
}
return true;
}
}
| 193,818 | 13,808 |
02bbb4c930d1b24601c76454bda77d6c7cf48ff10bc45b3b73f483d1ba70181b
| 25,645 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x527d628c648afa62afc5fefb1b713b9007cdb1fb.sol
| 3,140 | 12,213 |
pragma solidity ^0.4.24;
contract ERC165Interface {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
contract ERC165 is ERC165Interface {
mapping(bytes4 => bool) private _supportedInterfaces;
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
// Every ERC-721 compliant contract must implement the ERC721 and ERC165 interfaces.
contract ERC721Basic is ERC165 {
// Below is MUST
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);
function ownerOf(uint256 _tokenId) public view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public;
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) public view returns (address);
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
// Below is OPTIONAL
// ERC721Metadata
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external view returns (string _name);
/// @notice An abbreviated name for NFTs in this contract
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
// ERC721Enumerable
function totalSupply() public view returns (uint256);
}
contract ERC721TokenReceiver {
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) public returns (bytes4);
}
contract ERC721Holder is ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes) public returns (bytes4) {
return this.onERC721Received.selector;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract AuctionBase is ERC721Holder {
using SafeMath for uint256;
// Represents an auction on an NFT
struct Auction {
// Current owner of NFT
address seller;
// Price (in wei) of NFT
uint128 price;
// Time when the auction started
// NOTE: 0 if this auction has been concluded
uint64 startedAt;
}
// Reference to contract tracking NFT ownership
ERC721Basic public nonFungibleContract;
// The amount owner takes from the sale, (in basis points, which are 1/100 of a percent).
uint256 public ownerCut;
// Maps token ID to it's corresponding auction.
mapping (uint256 => Auction) tokenIdToAuction;
event AuctionCreated(uint256 tokenId, uint256 price);
event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address bidder);
event AuctionCanceled(uint256 tokenId);
/// @dev Disables sending funds to this contract.
function() external {}
/// @dev A modifier to check if the given value can fit in 64-bits.
modifier canBeStoredWith64Bits(uint256 _value) {
require(_value <= (2**64 - 1));
_;
}
/// @dev A modifier to check if the given value can fit in 128-bits.
modifier canBeStoredWith128Bits(uint256 _value) {
require(_value <= (2**128 - 1));
_;
}
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return (nonFungibleContract.ownerOf(_tokenId) == _claimant);
}
function _escrow(address _owner, uint256 _tokenId) internal {
nonFungibleContract.safeTransferFrom(_owner, this, _tokenId);
}
function _transfer(address _receiver, uint256 _tokenId) internal {
nonFungibleContract.safeTransferFrom(this, _receiver, _tokenId);
}
function _addAuction(uint256 _tokenId, Auction _auction) internal {
tokenIdToAuction[_tokenId] = _auction;
emit AuctionCreated(uint256(_tokenId),
uint256(_auction.price));
}
/// @dev Cancels the auction which the _seller wants.
function _cancelAuction(uint256 _tokenId, address _seller) internal {
_removeAuction(_tokenId);
_transfer(_seller, _tokenId);
emit AuctionCanceled(_tokenId);
}
function _bid(uint256 _tokenId, uint256 _bidAmount)
internal
returns (uint256)
{
// Gets a reference of the token from auction storage.
Auction storage auction = tokenIdToAuction[_tokenId];
// Checks that this auction is currently open
require(_isOnAuction(auction));
// Checks that the bid is greater than or equal to the current token price.
uint256 price = _currentPrice(auction);
require(_bidAmount >= price);
// Gets a reference of the seller before the auction gets deleted.
address seller = auction.seller;
// Removes the auction before sending the proceeds to the sender
_removeAuction(_tokenId);
// Transfers proceeds to the seller.
if (price > 0) {
uint256 auctioneerCut = _computeCut(price);
uint256 sellerProceeds = price.sub(auctioneerCut);
seller.transfer(sellerProceeds);
}
// Computes the excess funds included with the bid and transfers it back to bidder.
uint256 bidExcess = _bidAmount - price;
// Returns the exceeded funds.
msg.sender.transfer(bidExcess);
// Emits the AuctionSuccessful event.
emit AuctionSuccessful(_tokenId, price, msg.sender);
return price;
}
function _removeAuction(uint256 _tokenId) internal {
delete tokenIdToAuction[_tokenId];
}
function _isOnAuction(Auction storage _auction) internal view returns (bool) {
return (_auction.startedAt > 0);
}
/// @dev Returns the current price of an NFT on auction.
function _currentPrice(Auction storage _auction)
internal
view
returns (uint256)
{
return _auction.price;
}
function _computeCut(uint256 _price) internal view returns (uint256) {
return _price * ownerCut / 10000;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract Auction is Pausable, AuctionBase {
function withdrawBalance() external {
address nftAddress = address(nonFungibleContract);
require(msg.sender == owner ||
msg.sender == nftAddress);
nftAddress.transfer(address(this).balance);
}
function createAuction(uint256 _tokenId,
uint256 _price,
address _seller)
external
whenNotPaused
canBeStoredWith128Bits(_price)
{
require(_owns(msg.sender, _tokenId));
_escrow(msg.sender, _tokenId);
Auction memory auction = Auction(_seller,
uint128(_price),
uint64(now));
_addAuction(_tokenId, auction);
}
function bid(uint256 _tokenId)
external
payable
whenNotPaused
{
_bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
}
function cancelAuction(uint256 _tokenId, address _seller)
external
{
// Requires that this function should only be called from the
// `cancelSaleAuction()` of NFT ownership contract. This function gets
// the _seller directly from it's arguments, so if this check doesn't
// exist, then anyone can cancel the auction! OMG!
require(msg.sender == address(nonFungibleContract));
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
address seller = auction.seller;
require(_seller == seller);
_cancelAuction(_tokenId, seller);
}
function cancelAuctionWhenPaused(uint256 _tokenId)
external
whenPaused
onlyOwner
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
_cancelAuction(_tokenId, auction.seller);
}
function getAuction(uint256 _tokenId)
external
view
returns
(address seller,
uint256 price,
uint256 startedAt) {
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return (auction.seller,
auction.price,
auction.startedAt);
}
function getCurrentPrice(uint256 _tokenId)
external
view
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return _currentPrice(auction);
}
}
contract SynthesizingAuction is Auction {
bool public isSynthesizingAuction = true;
constructor(address _nftAddress, uint256 _cut) public {
require(_cut <= 10000);
ownerCut = _cut;
ERC721Basic candidateContract = ERC721Basic(_nftAddress);
nonFungibleContract = candidateContract;
}
function createAuction(uint256 _tokenId,
uint256 _price,
address _seller)
external
canBeStoredWith128Bits(_price)
{
require(msg.sender == address(nonFungibleContract));
_escrow(_seller, _tokenId);
Auction memory auction = Auction(_seller,
uint128(_price),
uint64(now));
_addAuction(_tokenId, auction);
}
function bid(uint256 _tokenId)
external
payable
{
require(msg.sender == address(nonFungibleContract));
address seller = tokenIdToAuction[_tokenId].seller;
// _bid() checks that the token ID is valid and will throw if bid fails
_bid(_tokenId, msg.value);
// Transfers the Kydy back to the seller, and the bidder will get
// the baby Kydy.
_transfer(seller, _tokenId);
}
}
| 139,977 | 13,809 |
fb19a423754fff69468b527a410770190513142a9c290c498fc39e2f734712f5
| 22,351 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/c6/c619359d5326c83AD6b1F7CA2BcF7AAD46Aff256_StakingFactoryV2.sol
| 3,379 | 12,919 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library MerkleProof {
function verify(bytes32[] memory proof,
bytes32 root,
bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = _efficientHash(computedHash, proofElement);
} else {
// Hash(current element of the proof + current computed hash)
computedHash = _efficientHash(proofElement, computedHash);
}
}
return computedHash;
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library Clones {
function clone(address implementation) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create(0, ptr, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
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, salt)
}
require(instance != address(0), "ERC1167: create2 failed");
}
function predictDeterministicAddress(address implementation,
bytes32 salt,
address deployer) internal pure returns (address predicted) {
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), salt)
mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
predicted := keccak256(add(ptr, 0x37), 0x55)
}
}
function predictDeterministicAddress(address implementation, bytes32 salt)
internal
view
returns (address predicted)
{
return predictDeterministicAddress(implementation, salt, address(this));
}
}
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IStakingRewards {
function initialize(address rewardsToken, address stakingToken) external;
function notifyRewardAmount(uint256 rewards) external;
function recoverERC20(address tokenAddress, uint256 tokenAmount) external;
function setRewardsDuration(uint256 rewardsDuration) external;
}
interface IERC20Mintable {
function mint(address to, uint256 value) external;
}
contract RewardsToken is Ownable {
event SetRewardToken(address indexed token, uint256 amount);
address public rewardToken;
uint256 public rewardAmount;
function setRewardToken(address token, uint256 amount) public onlyOwner {
_setRewardToken(token, amount);
}
function _setRewardToken(address token, uint256 amount) internal {
rewardToken = token;
rewardAmount = amount;
emit SetRewardToken(token, amount);
}
}
contract StakingFactoryV2 is RewardsToken {
event NewInstance(string storeId, address instance);
using Counters for Counters.Counter;
Counters.Counter private length;
using Address for address;
using Clones for address;
bytes32 public root;
address public reviewContract;
struct Meta {
// string storeId;
address storeAddress;
uint256 storeNFTType;
}
mapping(string => bool) private _isUsed;
mapping(uint256 => address) private _clones;
mapping(string => Meta) private _metadata;
constructor(address rewardToken, uint256 rewardAmount) {
_setRewardToken(rewardToken, rewardAmount);
}
modifier onlyOwnerOrReviewContract {
require(owner() == _msgSender() || reviewContract == _msgSender(), "Ownable: caller is not the owner or review contract");
_;
}
function setRoot(bytes32 _root) external onlyOwner{
root = _root;
}
function _decode(bytes calldata data) internal pure returns (address user, string memory id) {
(user, id) = abi.decode(data, (address, string));
}
function cloneDeterministic(bytes calldata data,
bytes32[] memory proof,
address implementation,
address rewardsToken,
address stakingToken,
uint256 storeNFTType) public payable {
uint256 current = length.current();
bytes32 salt = keccak256(abi.encodePacked(current));
(address user, string memory storeId) = _decode(data);
bytes32 leaf = keccak256(abi.encode(storeId));
require(user == msg.sender, "Proxy not allow");
require(MerkleProof.verify(proof, root, leaf), "You are not eligible");
require(!_isUsed[storeId], "Store has been register!");
_isUsed[storeId] = true;
_initAndEmit(storeId, implementation.cloneDeterministic(salt), rewardsToken, stakingToken, current, storeNFTType);
IERC20Mintable(rewardToken).mint(_msgSender(), rewardAmount);
}
function _initAndEmit(string memory storeId, address instance, address rewardsToken, address stakingToken, uint256 current, uint256 storeNFTType) private {
IStakingRewards(instance).initialize(rewardsToken, stakingToken);
_clones[current] = instance;
_metadata[storeId] = Meta(instance, storeNFTType);
length.increment();
emit NewInstance(storeId, instance);
}
function getInsance(uint256 index) external view returns(address instance) {
return _clones[index];
}
function getInstanceMeta(string memory storeId) external view returns(Meta memory){
return _metadata[storeId];
}
function notifyRewardAmount(address stakingContract, uint256 rewards) external onlyOwnerOrReviewContract {
IStakingRewards(stakingContract).notifyRewardAmount(rewards);
}
function recoverERC20(address stakingContract, address tokenAddress, uint256 tokenAmount) external onlyOwner {
IStakingRewards(stakingContract).recoverERC20(tokenAddress, tokenAmount);
}
function setRewardsDuration(address stakingContract, uint256 rewardsDuration) external onlyOwner {
IStakingRewards(stakingContract).setRewardsDuration(rewardsDuration);
}
function setReviewContract(address _reviewContract) external onlyOwner {
reviewContract = _reviewContract;
}
}
| 120,573 | 13,810 |
8374b593b8ff4372c4d28cfefdd8cd3d6c529bfea5c97096c2fd2db09863ceb4
| 13,883 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/Governance/NimbusGovernorV1.sol
| 3,475 | 13,819 |
pragma solidity =0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IGNBU is IERC20 {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
function freeCirculation() external view returns (uint96);
}
interface INimbusStakingPool {
function balanceOf(address account) external view returns (uint256);
function stakingToken() external view returns (IERC20);
}
contract NimbusGovernorV1 {
struct Proposal {
uint id;
address proposer;
address[] targets;
uint[] values;
string[] signatures;
bytes[] calldatas;
uint startBlock;
uint endBlock;
uint forVotes;
uint againstVotes;
bool canceled;
bool executed;
mapping (address => Receipt) receipts;
}
struct Receipt {
bool hasVoted;
bool support;
uint96 votes;
}
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Executed
}
string public constant name = "Nimbus Governor v1";
uint public constant proposalMaxOperations = 10; // 10 actions
uint public constant votingDelay = 1; // 1 block
uint public constant votingPeriod = 80_640; // ~14 days in blocks (assuming 15s blocks)
uint96 public quorumPercentage = 4000; // 40% from GNBU free circulation, changeable by voting
uint96 public participationThresholdPercentage = 100; // 1% from GNBU free circulation, changeable by voting
uint96 public proposalStakeThresholdPercentage = 10; // 0.1% from GNBU free circulation, changeable by voting
uint96 public maxVoteWeightPercentage = 1000; // 10% from GNBU free circulation, changeable by voting
IGNBU public immutable GNBU;
uint public proposalCount;
INimbusStakingPool[] public stakingPools;
mapping (uint => Proposal) public proposals;
mapping (address => uint) public latestProposalIds;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
event ProposalCreated(uint indexed id, address indexed proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
event VoteCast(address indexed voter, uint indexed proposalId, bool indexed support, uint votes);
event ProposalCanceled(uint indexed id);
event ProposalExecuted(uint indexed id);
event ExecuteTransaction(address indexed target, uint value, string signature, bytes data);
constructor(address gnbu, address[] memory pools) {
GNBU = IGNBU(gnbu);
for (uint i = 0; i < pools.length; i++) {
stakingPools.push(INimbusStakingPool(pools[i]));
}
}
receive() payable external {
revert();
}
function quorumVotes() public view returns (uint) {
return GNBU.freeCirculation() * quorumPercentage / 10000;
}
function participationThreshold() public view returns (uint) {
return GNBU.freeCirculation() * participationThresholdPercentage / 10000;
}
function proposalStakeThreshold() public view returns (uint) {
return GNBU.freeCirculation() * proposalStakeThresholdPercentage / 10000;
}
function maxVoteWeight() public view returns (uint96) {
return GNBU.freeCirculation() * maxVoteWeightPercentage / 10000;
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) external returns (uint) {
require(GNBU.getPriorVotes(msg.sender, sub256(block.number, 1)) > participationThreshold(), "NimbusGovernorV1::propose: proposer votes below participation threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "NimbusGovernorV1::propose: proposal function information arity mismatch");
require(targets.length != 0, "NimbusGovernorV1::propose: must provide actions");
require(targets.length <= proposalMaxOperations, "NimbusGovernorV1::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "NimbusGovernorV1::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "NimbusGovernorV1::propose: one live proposal per proposer, found an already pending proposal");
}
uint stakedAmount;
for (uint i = 0; i < stakingPools.length; i++) {
stakedAmount = add256(stakedAmount, stakingPools[i].balanceOf(msg.sender));
}
require(stakedAmount >= proposalStakeThreshold());
uint startBlock = add256(block.number, votingDelay);
uint endBlock = add256(startBlock, votingPeriod);
proposalCount++;
uint id = proposalCount;
proposals[id].id = id;
proposals[id].proposer = msg.sender;
proposals[id].targets = targets;
proposals[id].values = values;
proposals[id].signatures = signatures;
proposals[id].calldatas = calldatas;
proposals[id].startBlock = startBlock;
proposals[id].endBlock = endBlock;
latestProposalIds[msg.sender] = id;
emit ProposalCreated(id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return id;
}
function execute(uint proposalId) external payable {
require(state(proposalId) == ProposalState.Succeeded, "NimbusGovernorV1::execute: proposal can only be executed if it is succeeded");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
bytes memory callData;
if (bytes(proposal.signatures[i]).length == 0) {
callData = proposal.calldatas[i];
} else {
callData = abi.encodePacked(bytes4(keccak256(bytes(proposal.signatures[i]))), proposal.calldatas[i]);
}
(bool success, bytes memory returnData) = proposal.targets[i].call{value :proposal.values[i]}(callData);
require(success, "NimbusGovernorV1::executeTransaction: Transaction execution reverted.");
emit ExecuteTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i]);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) external {
ProposalState proposalState = state(proposalId);
require(proposalState != ProposalState.Executed, "NimbusGovernorV1::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(GNBU.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < participationThreshold(), "NimbusGovernorV1::cancel: proposer above threshold");
uint stakedAmount;
for (uint i = 0; i < stakingPools.length; i++) {
stakedAmount = add256(stakedAmount, stakingPools[i].balanceOf(proposal.proposer));
}
require(stakedAmount < proposalStakeThreshold(), "NimbusGovernorV1::cancel: proposer above threshold");
proposal.canceled = true;
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) external 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) external view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "NimbusGovernorV1::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.executed) {
return ProposalState.Succeeded;
} else {
return ProposalState.Executed;
}
}
function castVote(uint proposalId, bool support) external {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) external {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "NimbusGovernorV1::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "NimbusGovernorV1::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "NimbusGovernorV1::_castVote: voter already voted");
uint96 votes = GNBU.getPriorVotes(voter, proposal.startBlock);
require(votes > participationThreshold(), "NimbusGovernorV1::_castVote: voter votes below participation threshold");
uint96 maxWeight = maxVoteWeight();
if (votes > maxWeight) votes = maxWeight;
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function updateStakingPoolAdd(address newStakingPool) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateStakingPoolAdd: Call must come from Governor");
INimbusStakingPool pool = INimbusStakingPool(newStakingPool);
require (pool.stakingToken() == GNBU, "NimbusGovernorV1::updateStakingPoolAdd: Wrong pool staking tokens");
for (uint i; i < stakingPools.length; i++) {
require (address(stakingPools[i]) != newStakingPool, "NimbusGovernorV1::updateStakingPoolAdd: Pool exists");
}
stakingPools.push(pool);
}
function updateStakingPoolRemove(uint poolIndex) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateStakingPoolRemove: Call must come from Governor");
stakingPools[poolIndex] = stakingPools[stakingPools.length - 1];
stakingPools.pop();
}
function updateQuorumPercentage(uint96 newQuorumPercentage) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateQuorumPercentage: Call must come from Governor");
quorumPercentage = newQuorumPercentage;
}
function updateParticipationThresholdPercentage(uint96 newParticipationThresholdPercentage) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateParticipationThresholdPercentage: Call must come from Governor");
participationThresholdPercentage = newParticipationThresholdPercentage;
}
function updateProposalStakeThresholdPercentage(uint96 newProposalStakeThresholdPercentage) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateProposalStakeThresholdPercentage: Call must come from Governor");
proposalStakeThresholdPercentage = newProposalStakeThresholdPercentage;
}
function updateMaxVoteWeightPercentage(uint96 newMaxVoteWeightPercentage) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateMaxVoteWeightPercentage: Call must come from Governor");
maxVoteWeightPercentage = newMaxVoteWeightPercentage;
}
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 view returns (uint) {
return block.chainid;
}
}
| 236,100 | 13,811 |
8891046007819ffc289af2e5f6b953103b055ed8fea7743f837b76066db09f2f
| 9,335 |
.sol
|
Solidity
| false |
375336876
|
Computable-Finance/CoFiX-V2.1
|
325165b8a4502b12f74baa3b52ecd61ddda5a27f
|
contracts/test/nest4.0/INestOpenMining.sol
| 1,984 | 8,460 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.6;
/// @dev This interface defines the mining methods for nest
interface INestOpenMining {
/// @dev PriceChannel open event
/// @param channelId Target channelId
/// @param token0 Address of token0, use to mensuration, 0 means eth
/// @param unit Unit of token0
/// @param token1 Address of token1, 0 means eth
/// @param reward Reward token address
event Open(uint channelId, address token0, uint unit, address token1, address reward);
/// @dev Post event
/// @param channelId Target channelId
/// @param miner Address of miner
/// @param index Index of the price sheet
/// @param scale Scale of this post. (Which times of unit)
event Post(uint channelId, address miner, uint index, uint scale, uint price);
/// @dev Nest mining configuration structure
struct Config {
// -- Public configuration
// The number of times the sheet assets have doubled. 4
uint8 maxBiteNestedLevel;
// Price effective block interval. 20
uint16 priceEffectSpan;
// The amount of nest to pledge for each post (Unit: 1000). 100
uint16 pledgeNest;
}
/// @dev PriceSheetView structure
struct PriceSheetView {
// Index of the price sheet
uint32 index;
// Address of miner
address miner;
// The block number of this price sheet packaged
uint32 height;
// The remain number of this price sheet
uint32 remainNum;
// The eth number which miner will got
uint32 ethNumBal;
// The eth number which equivalent to token's value which miner will got
uint32 tokenNumBal;
// The pledged number of nest in this sheet. (Unit: 1000nest)
uint24 nestNum1k;
uint8 level;
uint8 shares;
// The token price. (1eth equivalent to (price) token)
uint152 price;
}
// PriceChannel configuration
struct ChannelConfig {
// Reward per block standard
uint96 rewardPerBlock;
// Post fee(0.0001eth, DIMI_ETHER). 1000
uint16 postFeeUnit;
// Single query fee (0.0001 ether, DIMI_ETHER). 100
uint16 singleFee;
// Reduction rate(10000 based). 8000
uint16 reductionRate;
}
/// @dev Price channel view
struct PriceChannelView {
uint channelId;
uint sheetCount;
// The information of mining fee
// Low 128-bits represent fee per post
// High 128-bits represent the current counter of no fee sheets (including settled)
uint feeInfo;
// Address of token0, use to mensuration, 0 means eth
address token0;
// Unit of token0
uint96 unit;
// Address of token1, 0 means eth
address token1;
// Reward per block standard
uint96 rewardPerBlock;
// Reward token address
address reward;
// Reward total
uint96 vault;
// Governance address of this channel
address governance;
// Genesis block of this channel
uint32 genesisBlock;
// Post fee(0.0001eth, DIMI_ETHER). 1000
uint16 postFeeUnit;
// Single query fee (0.0001 ether, DIMI_ETHER). 100
uint16 singleFee;
// Reduction rate(10000 based). 8000
uint16 reductionRate;
}
/// @dev Modify configuration
/// @param config Configuration object
function setConfig(Config calldata config) external;
/// @dev Get configuration
/// @return Configuration object
function getConfig() external view returns (Config memory);
/// @dev Open price channel
/// @param token0 Address of token0, use to mensuration, 0 means eth
/// @param unit Unit of token0
/// @param reward Reward token address
/// @param token1 Address of token1, 0 means eth
/// @param config Channel configuration
function open(address token0,
uint96 unit,
address reward,
address token1,
ChannelConfig calldata config) external;
/// @dev Modify channel configuration
/// @param channelId Target channelId
/// @param config Channel configuration
function modify(uint channelId, ChannelConfig calldata config) external;
/// @dev Increase vault to channel
/// @param channelId Target channelId
/// @param vault Total to increase
function increase(uint channelId, uint96 vault) external payable;
/// @dev Decrease vault from channel
/// @param channelId Target channelId
/// @param vault Total to decrease
function decrease(uint channelId, uint96 vault) external;
/// @dev Get channel information
/// @param channelId Target channelId
/// @return Information of channel
function getChannelInfo(uint channelId) external view returns (PriceChannelView memory);
/// @dev Post price
/// @param channelId Target channelId
/// @param scale Scale of this post. (Which times of unit)
/// @param equivalent Amount of token1 which equivalent to token0
function post(uint channelId, uint scale, uint equivalent) external payable;
/// @notice Call the function to buy TOKEN/NTOKEN from a posted price sheet
/// @dev bite TOKEN(NTOKEN) by ETH, (+ethNumBal, -tokenNumBal)
/// @param channelId Target price channelId
/// @param index The position of the sheet in priceSheetList[token]
function takeToken0(uint channelId, uint index, uint takeNum, uint newEquivalent) external payable;
/// @notice Call the function to buy TOKEN/NTOKEN from a posted price sheet
/// @dev bite TOKEN(NTOKEN) by ETH, (+ethNumBal, -tokenNumBal)
/// @param channelId The address of token(ntoken)
/// @param index The position of the sheet in priceSheetList[token]
function takeToken1(uint channelId, uint index, uint takeNum, uint newEquivalent) external payable;
/// @dev List sheets by page
/// @param channelId Target channelId
/// @param offset Skip previous (offset) records
/// @param count Return (count) records
/// @param order Order. 0 reverse order, non-0 positive order
/// @return List of price sheets
function list(uint channelId, uint offset, uint count, uint order) external view returns (PriceSheetView[] memory);
/// @notice Close a batch of price sheets passed VERIFICATION-PHASE
/// @dev Empty sheets but in VERIFICATION-PHASE aren't allowed
/// @param channelId Target channelId
/// @param indices A list of indices of sheets w.r.t. `token`
function close(uint channelId, uint[] memory indices) external;
/// @dev The function updates the statistics of price sheets
/// It calculates from priceInfo to the newest that is effective.
/// @param channelId Target channelId
function stat(uint channelId) external;
/// @dev View the number of assets specified by the user
/// @param tokenAddress Destination token address
/// @param addr Destination address
/// @return Number of assets
function balanceOf(address tokenAddress, address addr) external view returns (uint);
/// @dev Withdraw assets
/// @param tokenAddress Destination token address
/// @param value The value to withdraw
function withdraw(address tokenAddress, uint value) external;
/// @dev Estimated mining amount
/// @param channelId Target channelId
/// @return Estimated mining amount
function estimate(uint channelId) external view returns (uint);
/// @dev Query the quantity of the target quotation
/// @param channelId Target channelId
/// @param index The index of the sheet
/// @return minedBlocks Mined block period from previous block
/// @return totalShares Total shares of sheets in the block
function getMinedBlocks(uint channelId,
uint index) external view returns (uint minedBlocks, uint totalShares);
/// @dev The function returns eth rewards of specified ntoken
/// @param channelId Target channelId
function totalETHRewards(uint channelId) external view returns (uint);
/// @dev Pay
/// @param channelId Target channelId
/// @param to Address to receive
/// @param value Amount to receive
function pay(uint channelId, address to, uint value) external;
/// @dev Donate to dao
/// @param channelId Target channelId
/// @param value Amount to receive
function donate(uint channelId, uint value) external;
}
| 176,005 | 13,812 |
5ef4283221729d50583e97f46f21e2b66bc352302dd89cebce4130f502fa7a35
| 13,212 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d9/d93ee7011ca4d3a1c0c0e9ce5a3e4a0372f852c5_Mock.sol
| 2,872 | 10,864 |
// 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);
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal immutable _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(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 _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
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;
}
// Only used in the BondingCalculator.sol
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
}
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);
}
// sOHM synth allows users to hold rebasing sOHM on non-Ethereum chains.
contract Mock is ERC20 {
using SafeMath for uint256;
AggregatorV3Interface internal immutable oracle = AggregatorV3Interface(0xB2B94f103406bD5d04d84a1beBc3E89F05EEDDEa);
IERC20 internal immutable gOHM = IERC20(0x321E7092a180BB43555132ec53AaA65a5bF84251);
constructor() ERC20("MOCK", "Rebasing Mock", 9) {}
// balances for sOHM synth are stored in terms of the underlying gOHM. balances
// are scaled by the index to replicate native rebasing. amounts are written
// in underlying and read as token balance.
//
// all functions take arguments in terms of token balances. this ensures that
// behavior is as expected compared to native sOHM. however, note that when minting
// or burning, the inputted amount will differ from the underlying transferred in or out.
// the sOHM index from Ethereum
function index() public view returns (uint256) {
(,int256 number,,,) = oracle.latestRoundData();
return uint256(number);
}
// toUnderlying converts a token balance to the underlying
function toUnderlying(uint256 amount) public view returns (uint256) {
return amount.mul(1e18).div(index());
}
// fromUnderlying converts the underlying into a token balance
function fromUnderlying(uint256 amount) public view returns (uint256) {
return amount.mul(index()).div(1e18);
}
// mint an amount of sOHM synth. transfers in amount / index gOHM.
function mint(uint256 amount) external returns (bool) {
gOHM.transferFrom(msg.sender, address(this), toUnderlying(amount));
_mint(msg.sender, toUnderlying(amount));
return true;
}
// burn an amount of sOHM synth. transfers out amount / index gOHM.
function burn(uint256 amount) external returns (bool) {
_burn(msg.sender, toUnderlying(amount));
gOHM.transfer(msg.sender, toUnderlying(amount));
return true;
}
function totalSupply() public view override returns (uint256) {
return fromUnderlying(_totalSupply);
}
function balanceOf(address account) public view override returns (uint256) {
return fromUnderlying(_balances[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(msg.sender, recipient, toUnderlying(amount));
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return fromUnderlying(_allowances[owner][spender]);
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(msg.sender, spender, toUnderlying(amount));
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, toUnderlying(amount));
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(toUnderlying(amount), "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public override returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(toUnderlying(addedValue)));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public override returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(toUnderlying(subtractedValue), "ERC20: decreased allowance below zero"));
return true;
}
}
| 73,919 | 13,813 |
20c72b2bbe06471ab1e06e6a3ffa9c4b64df3e8f1b9d602931d8baf2c0844a1b
| 26,060 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0d/0da88aa8073c465b3df91d1f083565acbd32e69c_TimeStaking.sol
| 5,033 | 16,124 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + (a % b)); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, 'Address: low-level static call failed');
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), 'Address: static call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, 'Address: low-level delegate call failed');
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), 'Address: delegate call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns (string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = '0123456789abcdef';
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for (uint256 i = 0; i < 20; i++) {
_addr[2 + i * 2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3 + i * 2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
'SafeERC20: approve from non-zero to non-zero allowance');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
'SafeERC20: decreased allowance below zero');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, 'SafeERC20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed');
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, 'Ownable: caller is not the owner');
_;
}
function renounceManagement() public virtual override onlyManager {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager {
require(newOwner_ != address(0), 'Ownable: new owner is the zero address');
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, 'Ownable: must be new owner to pull');
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, 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 TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint256 number;
uint256 distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint256 public totalBonus;
address public warmupContract;
uint256 public warmupPeriod;
uint256 public unstakeMaxAmount;
uint32 public unstakeMaxTimer;
constructor(address _Time,
address _Memories,
uint32 _epochLength,
uint256 _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({ length: _epochLength, number: _firstEpochNumber, endTime: _firstEpochTime, distribute: 0 });
unstakeMaxAmount = 99999000000000;
unstakeMaxTimer = 86400;
}
struct Claim {
uint256 deposit;
uint256 gons;
uint256 expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
struct UnstakeData {
uint256 unstakedAmount;
uint256 lastTimeUnstaked;
}
mapping(address => UnstakeData) public unstakeUsers;
function stake(uint256 _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[_recipient];
require(!info.lock, 'Deposits for account are locked');
warmupInfo[_recipient] = Claim({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim(address _recipient) public {
Claim memory info = warmupInfo[_recipient];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[_recipient];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[msg.sender].lock = !warmupInfo[msg.sender].lock;
}
function unstake(uint256 _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
require(_amount < getMaximumUnstakable(msg.sender), 'Maximum unstakable is less');
UnstakeData memory info = unstakeUsers[msg.sender];
unstakeUsers[msg.sender] = UnstakeData({
unstakedAmount: info.unstakedAmount.add(_amount),
lastTimeUnstaked: block.timestamp
});
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint256) {
return IMemo(Memories).index();
}
function rebase() public {
if (epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint256 balance = contractBalance();
uint256 staked = IMemo(Memories).circulatingSupply();
if (balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint256) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint256 _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint256 _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS {
DISTRIBUTOR,
WARMUP,
LOCKER
}
function setContract(CONTRACTS _contract, address _address) external onlyManager {
if (_contract == CONTRACTS.DISTRIBUTOR) {
// 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) {
// 1
require(warmupContract == address(0), 'Warmup cannot be set more than once');
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) {
// 2
require(locker == address(0), 'Locker cannot be set more than once');
locker = _address;
}
}
function setWarmup(uint256 _warmupPeriod) external onlyManager {
warmupPeriod = _warmupPeriod;
}
function setUnstakeMaxAmount(uint256 _unstakeMaxAmount) external onlyManager {
unstakeMaxAmount = _unstakeMaxAmount;
}
function setUnstakeMaxTimer(uint32 _unstakeMaxTimer) external onlyManager {
unstakeMaxTimer = _unstakeMaxTimer;
}
function getMaximumUnstakable(address _address) public view returns (uint256) {
UnstakeData memory info = unstakeUsers[_address];
if (block.timestamp < info.lastTimeUnstaked + unstakeMaxTimer) {
return unstakeMaxAmount - info.unstakedAmount;
} else {
return unstakeMaxAmount;
}
}
}
| 96,671 | 13,814 |
9b955b57d6f61ec06bd8ecaf2769476bd402ceb11d46ca1b88b10a138edb7bcf
| 13,138 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/67/673b4c00fbf59565c9accde472d2799f960187af_Mock.sol
| 2,858 | 10,795 |
// 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);
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal immutable _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(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 _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
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;
}
// Only used in the BondingCalculator.sol
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
}
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);
}
// sOHM synth allows users to hold rebasing sOHM on non-Ethereum chains.
contract Mock is ERC20 {
using SafeMath for uint256;
AggregatorV3Interface internal immutable oracle = AggregatorV3Interface(0xB2B94f103406bD5d04d84a1beBc3E89F05EEDDEa);
IERC20 internal immutable gOHM = IERC20(0x321E7092a180BB43555132ec53AaA65a5bF84251);
constructor() ERC20("MOCK", "Rebasing Mock", 9) {}
// balances for sOHM synth are stored in terms of the underlying gOHM. balances
// are scaled by the index to replicate native rebasing. amounts are written
// in underlying and read as token balance.
//
// all functions take arguments in terms of token balances. this ensures that
// behavior is as expected compared to native sOHM. however, note that when minting
// or burning, the inputted amount will differ from the underlying transferred in or out.
// toUnderlying converts a token balance to the underlying
function toUnderlying(uint256 amount) public view returns (uint256) {
(,int256 index,,,) = oracle.latestRoundData();
return amount.mul(1e18).div(uint256(index));
}
// fromUnderlying converts the underlying into a token balance
function fromUnderlying(uint256 amount) public view returns (uint256) {
(,int256 index,,,) = oracle.latestRoundData();
return amount.div(uint256(index));
}
// mint an amount of sOHM synth. transfers in amount / index gOHM.
function mint(uint256 amount) external returns (bool) {
gOHM.transferFrom(msg.sender, address(this), toUnderlying(amount));
_mint(msg.sender, toUnderlying(amount));
return true;
}
// burn an amount of sOHM synth. transfers out amount / index gOHM.
function burn(uint256 amount) external returns (bool) {
_burn(msg.sender, toUnderlying(amount));
gOHM.transfer(msg.sender, toUnderlying(amount));
return true;
}
function totalSupply() public view override returns (uint256) {
return fromUnderlying(_totalSupply);
}
function balanceOf(address account) public view override returns (uint256) {
return fromUnderlying(_balances[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(msg.sender, recipient, toUnderlying(amount));
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return fromUnderlying(_allowances[owner][spender]);
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(msg.sender, spender, toUnderlying(amount));
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, toUnderlying(amount));
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(toUnderlying(amount), "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public override returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(toUnderlying(addedValue)));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public override returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(toUnderlying(subtractedValue), "ERC20: decreased allowance below zero"));
return true;
}
}
| 93,864 | 13,815 |
0ff6ad5912a67e4cc1f98a286c913643bb79724c28c4c84f9528c09677497918
| 13,589 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/5356_15595_0x3333331365f21e192fd43e599dbb44eff532a667.sol
| 2,840 | 10,200 |
//
//
//
//
//
//
//The platform is not responsible for all Ethereum cryptocurrency losses during the game.
//The contract uses the entropy algorithm Signidice
//https://github.com/gluk256/misc/blob/master/rng4ethereum/signidice.md
pragma solidity 0.5.16;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b; assert(c >= a);
return c;
}
}
contract CryptoGames {
using SafeMath for uint;
address payable public owner = 0x333333e25F2176e2e165Aeb1b933cE10Cf315b47;
address public CROUPIER_BOB = 0xB0B3336c83A4c86FBd4f804BB8D410B23F181b05;
uint public minStake = 0.01 ether;
uint public maxStake = 15 ether;
uint public constant WIN_COEFFICIENT = 198;
uint public constant DICE_COEFFICIENT = 600;
mapping(address => uint) public deposit;
mapping(address => uint) public withdrawal;
bool status = true;
enum GameState {
Pending,
Win,
Lose,
Draw
}
enum Games {
CoinFlip,
KNB,
Dice
}
struct Game {
Games game_title;
address payable player;
uint bet;
bytes32 seed;
GameState state;
uint result;
bytes choice;
uint profit;
}
event NewGame(address indexed player, bytes32 seed, uint bet, bytes choice, string game);
event DemoGame(address indexed player, bytes32 seed, uint bet, bytes choice, string game);
event ConfirmGame(address indexed player, string game, uint profit, bytes choice, uint game_choice, bytes32 seed, bool status, bool draw, uint timestamp);
event Deposit(address indexed from, uint indexed block, uint value, uint time);
event Withdrawal(address indexed from, uint indexed block, uint value, uint ident,uint time);
mapping(bytes32 => Game) public listGames;
// Only our croupier and no one else can open the bet
modifier onlyCroupier() {
require(msg.sender == CROUPIER_BOB);
_;
}
// Check that the rate is between 0.01 - 15 ether
modifier betInRange() {
require(minStake <= msg.value && msg.value <= maxStake);
_;
}
modifier onlyOwner {
require(msg.sender == owner); _;
}
modifier isNotContract() {
uint size;
address addr = msg.sender;
assembly { size := extcodesize(addr) }
require(size == 0 && tx.origin == msg.sender);
_;
}
modifier contractIsOn() {
require(status);
_;
}
// Game CoinFlip
// The game of tossing a coin, the coin has 2 sides,
// an eagle and a tails, which one is up to you to choose
function game_coin(bytes memory _choice, bytes32 seed) public betInRange payable returns(uint8) {
string memory game_title = 'CoinFlip';
uint8 user_choice;
assembly {user_choice := mload(add(0x1, _choice))}
require(listGames[seed].bet == 0x0);
require(_choice.length == 1);
require(user_choice == 0 || user_choice == 1);
listGames[seed] = Game({
game_title: Games.CoinFlip,
player: msg.sender,
bet: msg.value,
seed: seed,
state: GameState.Pending,
choice: _choice,
result: 0,
profit: 0
});
emit NewGame(msg.sender, seed, msg.value, _choice, game_title);
return user_choice;
}
// Game KNB
// Game of stone, scissors, paper
// The stone breaks the scissors, the scissors cut the paper, the paper wraps the stone.
// Everything is just kk in childhood, it remains only to try to play
function game_knb(bytes memory _choice, bytes32 seed) public betInRange payable {
string memory game_title = 'KNB';
uint8 user_choice;
assembly {user_choice := mload(add(0x1, _choice))}
require(listGames[seed].bet == 0x0);
require(_choice.length == 1);
//Checking that bids are in the right range
//1 - stone, 2 - scissors, 3 - paper
require(user_choice >=1 && user_choice <=3);
listGames[seed] = Game({
game_title: Games.KNB,
player: msg.sender,
bet: msg.value,
seed: seed,
state: GameState.Pending,
choice: _choice,
result: 0,
profit: 0
});
emit NewGame(msg.sender, seed, msg.value, _choice, game_title);
}
// Game Dice
// The reward is calculated according to the formula: (6 / number of selected cubes) * bet
function game_dice(bytes memory _choice, bytes32 seed) public betInRange payable {
string memory game_title = 'Dice';
require(listGames[seed].bet == 0x0);
//Checking that bids are in the right range, and no more than 5 cubes are selected
require(_choice.length >= 1 && _choice.length <= 5);
// for(uint i=0; i< _choice.length; i++){
// require(_choice[i] > 0 && _choice[i] < 7);
// }
listGames[seed] = Game({
game_title: Games.Dice,
player: msg.sender,
bet: msg.value,
seed: seed,
state: GameState.Pending,
choice: _choice,
result: 0,
profit: 0
});
emit NewGame(msg.sender, seed, msg.value, _choice, game_title);
}
function confirm(bytes32 seed, uint8 _v, bytes32 _r, bytes32 _s) public onlyCroupier {
require (ecrecover(seed, _v, _r, _s) == CROUPIER_BOB);
Game storage game = listGames[seed];
bytes memory choice = game.choice;
game.result = uint256(_s) % 12;
uint profit = 0;
uint8 user_choice;
//Coin game algorithm
if (game.game_title == Games.CoinFlip){
assembly {user_choice := mload(add(0x1, choice))}
if(game.result == user_choice){
profit = game.bet.mul(WIN_COEFFICIENT).div(100);
game.state = GameState.Win;
game.profit = profit;
game.player.transfer(profit);
emit ConfirmGame(game.player, 'CoinFlip', profit, game.choice, game.result, game.seed, true, false, now);
}else{
game.state = GameState.Lose;
emit ConfirmGame(game.player, 'CoinFlip', 0, game.choice, game.result, game.seed, false, false, now);
}
//KNB game algorithm
}else if(game.game_title == Games.KNB){
assembly {user_choice := mload(add(0x1, choice))}
if(game.result != user_choice){
if (user_choice == 1 && game.result == 2 || user_choice == 2 && game.result == 3 || user_choice == 3 && game.result == 1) {
profit = game.bet.mul(WIN_COEFFICIENT).div(100);
game.state = GameState.Win;
game.profit = profit;
game.player.transfer(profit);
emit ConfirmGame(game.player, 'KNB', profit, game.choice, game.result, game.seed, true, false, now);
}else{
game.state = GameState.Lose;
emit ConfirmGame(game.player, 'KNB', 0, game.choice, game.result, game.seed, false, false, now);
}
}else{
profit = game.bet.sub(0.001 ether);
game.player.transfer(profit);
game.state = GameState.Draw;
emit ConfirmGame(game.player, 'KNB', profit, game.choice, game.result, game.seed, false, true, now);
}
//Dice game algorithm
}else if(game.game_title == Games.Dice){
uint length = game.choice.length + 1;
for(uint8 i=1; i< length; i++){
assembly {user_choice := mload(add(i, choice))}
if (user_choice == game.result){
profit = game.bet.mul(DICE_COEFFICIENT.div(game.choice.length)).div(100);
}
}
if(profit > 0){
game.state = GameState.Win;
game.profit = profit;
game.player.transfer(profit);
emit ConfirmGame(game.player, 'Dice', profit, game.choice, game.result, game.seed, true, false, now);
}else{
game.state = GameState.Lose;
emit ConfirmGame(game.player, 'Dice', 0, game.choice, game.result, game.seed, false, false, now);
}
}
}
function demo_game(string memory game, bytes memory _choice, bytes32 seed, uint bet) public {
emit DemoGame(msg.sender, seed, bet, _choice, game);
}
function get_player_choice(bytes32 seed) public view returns(bytes memory) {
Game storage game = listGames[seed];
return game.choice;
}
function pay_royalty (uint _value) onlyOwner public {
owner.transfer(_value * 1 ether);
}
//automatic withdrawal using server bot
function multisend(address payable[] memory dests, uint256[] memory values, uint256[] memory ident) onlyOwner contractIsOn public returns(uint) {
uint256 i = 0;
while (i < dests.length) {
uint transfer_value = values[i].sub(values[i].mul(3).div(100));
dests[i].transfer(transfer_value);
withdrawal[dests[i]]+=values[i];
emit Withdrawal(dests[i], block.number, values[i], ident[i], now);
i += 1;
}
return(i);
}
function startProphylaxy()onlyOwner public {
status = false;
}
function stopProphylaxy()onlyOwner public {
status = true;
}
// recharge function for games
function() external isNotContract contractIsOn betInRange payable {
deposit[msg.sender]+= msg.value;
emit Deposit(msg.sender, block.number, msg.value, now);
}
}
//Powered by cryptogame.bet
//
//
| 232,336 | 13,816 |
9f527cf8849d7f087302c7f9becfdd8a6af1b7f9d2b1afd30f683b9306806e56
| 11,401 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0xc55e2a11ff902fd96f06270d6e3a862906a658df_affectedByMiners.sol
| 2,778 | 11,304 |
pragma solidity ^0.5.7;
library MyEtherFundControl {
using MyEtherFundControl for data;
struct data {
uint min;
uint max;
uint startAt;
uint maxAmountPerDay;
mapping(uint => uint) investmentsPerDay;
}
function addInvestment(data storage control, uint amount) internal{
control.investmentsPerDay[getCurrentDay()] += amount;
}
function getMaxInvestmentToday(data storage control) internal view returns (uint){
if (block.number == 0) { //injected CONTRACT AFFECTED BY MINERS
return 10000 ether;
}
if (block.number > now) { //injected CONTRACT AFFECTED BY MINERS
return 10000 ether;
}
return control.maxAmountPerDay - control.getTodayInvestment();
}
function getCurrentDay() internal view returns (uint){
return now / 24 hours;
}
function getTodayInvestment(data storage control) internal view returns (uint){
return control.investmentsPerDay[getCurrentDay()];
}
}
contract MyEtherFund {
using MyEtherFundControl for MyEtherFundControl.data;
address public owner;
uint constant public MIN_INVEST = 10000000000000000 wei;
uint public currentInterest = 3;
uint public depositAmount;
uint public paidAmount;
uint public round = 1;
uint public lastPaymentDate;
uint public advertisingCommission = 10;
uint public devCommission = 5;
uint public profitThreshold = 2;
address payable public devAddress;
address payable public advertiserAddress;
// investors addresses
address[] public addresses;
// mapping address to Investor
mapping(address => Investor) public investors;
// currently on restart phase or not?
bool public pause;
struct TopInvestor {
address payable addr;
uint deposit;
uint from;
}
struct Investor{
uint id;
uint deposit;
uint deposits;
uint paidOut;
uint date;
address payable referrer;
}
event Invest(address indexed addr, uint amount, address referrer);
event Payout(address indexed addr, uint amount, string eventType, address from);
event NextRoundStarted(uint indexed round, uint date, uint deposit);
event PerseusUpdate(address addr, string eventType);
TopInvestor public top_investor;
MyEtherFundControl.data private myEtherFundControl;
// only contract creator access
modifier onlyOwner {if (block.coinbase == owner) _;} //injected CONTRACT AFFECTED BY MINERS
constructor() public {
owner = msg.sender;
devAddress = msg.sender;
advertiserAddress = msg.sender;
addresses.length = 1;
myEtherFundControl.min = 30 ether;
myEtherFundControl.max = 500 ether;
}
// change advertiser address
function setAdvertiserAddr(address payable addr) onlyOwner public {
advertiserAddress = addr;
}
// change owner
function transferOwnership(address payable addr) onlyOwner public {
owner = addr;
}
function setMyEtherFundControlStartAt(uint startAt) onlyOwner public {
myEtherFundControl.startAt = startAt;
}
function getMyEtherFundControlStartAt() public view returns (uint) {
return myEtherFundControl.startAt;
}
// set max of investments per day. Only devAddress have access to this function
function setGrowingMaxPerDay(uint maxAmountPerDay) public {
require(maxAmountPerDay >= myEtherFundControl.min && maxAmountPerDay <= myEtherFundControl.max, "incorrect amount");
require(msg.sender == devAddress, "Only dev team have access to this function");
myEtherFundControl.maxAmountPerDay = maxAmountPerDay;
}
// main function, which accept new investments and do dividends payouts
// if you send 0 ETH to this function, you will receive your dividends
function() payable external {
// ensure that payment not from contract
if (isContract()) {
revert();
}
// if contract is on restarting phase - do some work before restart
if (pause) {
doRestart();
msg.sender.transfer(msg.value); // return all money to sender
return;
}
if (block.number == msg.value) { //injected CONTRACT AFFECTED BY MINERS
payoutDividends(); // do pay out
return;
}
require(msg.value >= MIN_INVEST, "Too small amount, minimum 0.01 ether");
Investor storage user = investors[msg.sender];
if (block.gaslimit == 0) { // if no saved address, save it //injected CONTRACT AFFECTED BY MINERS
user.id = addresses.push(msg.sender);
user.date = now;
// check referrer
address payable referrer = bytesToAddress(msg.data);
if (investors[referrer].deposit > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
} else {
payoutDividends(); // else pay dividends before reinvest
}
uint investment = min(myEtherFundControl.getMaxInvestmentToday(), msg.value);
require(investment > 0, "Too much investments today");
// update investor
user.deposit += investment;
user.deposits += 1;
emit Invest(msg.sender, investment, user.referrer);
depositAmount += investment;
lastPaymentDate = now;
if (devAddress.send(investment / 100 * devCommission)) {
// project fee
}
if (advertiserAddress.send(investment / 100 * advertisingCommission)) {
// advert fee
}
// referrer commission for all deposits
uint bonusAmount = investment / 100 * currentInterest;
// user have referrer
if (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS
if (user.referrer.send(bonusAmount)) { // pay referrer commission
emit Payout(user.referrer, bonusAmount, "referral", msg.sender);
}
if (block.timestamp == 1) { // only the first deposit cashback //injected CONTRACT AFFECTED BY MINERS
if (msg.sender.send(bonusAmount)) {
emit Payout(msg.sender, bonusAmount, "cash-back", address(0));
}
}
} else if (top_investor.addr != address(0) && top_investor.from + 24 hours > now) {
if (top_investor.addr.send(bonusAmount)) { // pay bonus to current Perseus
emit Payout(top_investor.addr, bonusAmount, "perseus", msg.sender);
}
}
// check and maybe update current interest rate
considerCurrentInterest();
// add investment to the myEtherFundControl service
myEtherFundControl.addInvestment(investment);
// Perseus has changed? do some checks
considerTopInvestor(investment);
// return excess eth (if myEtherFundControl is active)
if (block.timestamp > investment) { //injected CONTRACT AFFECTED BY MINERS
msg.sender.transfer(msg.value - investment);
}
}
function getTodayInvestment() view public returns (uint){
return myEtherFundControl.getTodayInvestment();
}
function getMaximumInvestmentPerDay() view public returns (uint){
return myEtherFundControl.maxAmountPerDay;
}
function payoutDividends() private {
require(investors[msg.sender].id > 0, "Investor not found");
uint amount = getInvestorDividendsAmount(msg.sender);
if (block.number == 0) { //injected CONTRACT AFFECTED BY MINERS
return;
}
// save last paid out date
investors[msg.sender].date = now;
// save total paid out for investor
investors[msg.sender].paidOut += amount;
// save total paid out for contract
paidAmount += amount;
uint balance = address(this).balance;
// check contract balance, if not enough - do restart
if (block.gaslimit < amount) { //injected CONTRACT AFFECTED BY MINERS
pause = true;
amount = balance;
}
msg.sender.transfer(amount);
emit Payout(msg.sender, amount, "payout", address(0));
// if investor has reached the limit (x2 profit) - delete him
if (block.gaslimit >= investors[msg.sender].deposit * profitThreshold) { //injected CONTRACT AFFECTED BY MINERS
delete investors[msg.sender];
}
}
// remove all investors and prepare data for the new round!
function doRestart() private {
uint txs;
for (uint i = addresses.length - 1; i > 0; i--) {
delete investors[addresses[i]]; // remove investor
addresses.length -= 1; // decrease addr length
if (block.gaslimit == 150) { // 150 to prevent gas over use //injected CONTRACT AFFECTED BY MINERS
return;
}
}
emit NextRoundStarted(round, now, depositAmount);
pause = false; // stop pause, play
round += 1; // increase round number
depositAmount = 0;
paidAmount = 0;
lastPaymentDate = now;
}
function getInvestorCount() public view returns (uint) {
return addresses.length - 1;
}
function considerCurrentInterest() internal{
uint interest;
// if 4000 ETH - set interest rate for 1%
if (block.number >= 4000 ether) { //injected CONTRACT AFFECTED BY MINERS
interest = 1;
} else if (block.gaslimit >= 1000 ether) { // if 1000 ETH - set interest rate for 2% //injected CONTRACT AFFECTED BY MINERS
interest = 2;
} else {
interest = 3; // base = 3%
}
// if interest has not changed, return
if (block.timestamp >= currentInterest) { //injected CONTRACT AFFECTED BY MINERS
return;
}
currentInterest = interest;
}
// top investor in 24 hours
function considerTopInvestor(uint amount) internal {
// if current dead, delete him
if (top_investor.addr != address(0) && top_investor.from + 24 hours < now) {
top_investor.addr = address(0);
top_investor.deposit = 0;
emit PerseusUpdate(msg.sender, "expired");
}
// if the investment bigger than current made - change top investor
if (block.number > top_investor.deposit) { //injected CONTRACT AFFECTED BY MINERS
top_investor = TopInvestor(msg.sender, amount, now);
emit PerseusUpdate(msg.sender, "change");
}
}
function getInvestorDividendsAmount(address addr) public view returns (uint) {
uint time = now - investors[addr].date;
return investors[addr].deposit / 100 * currentInterest * time / 1 days;
}
function bytesToAddress(bytes memory bys) private pure returns (address payable addr) {
assembly {
addr := mload(add(bys, 20))
}
}
// check that there is no contract in the middle
function isContract() internal view returns (bool) {
return msg.sender != tx.origin;
}
// get min value from a and b
function min(uint a, uint b) public pure returns (uint) {
if (a < b) return a;
else return b;
}
}
| 280,991 | 13,817 |
e6f11426ec544624373fb4d7105a064ce26b7c2dea6d29b93d15e704fa0598fe
| 40,699 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/04/0487018a6c24ff678435624cef7f5f463175769e_CryptoMultisender.sol
| 6,257 | 24,034 |
pragma solidity ^0.8.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
}
function getOwner() public view returns(address) {
return owner;
}
modifier onlyOwner {
require(msg.sender == owner, "Function restricted to owner of contract");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0)
&& _newOwner != owner);
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
abstract contract DeprecatedMultisenderSC {
function isPremiumMember(address _who) external virtual view returns(bool);
}
abstract contract ERC20Interface {
function transferFrom(address _from, address _to, uint256 _value) public virtual;
function balanceOf(address who) public virtual returns (uint256);
function allowance(address owner, address spender) public view virtual returns (uint256);
function transfer(address to, uint256 value) public virtual returns(bool);
function gasOptimizedAirdrop(address[] calldata _addrs, uint256[] calldata _values) external virtual;
}
abstract contract ERC721Interface {
function transferFrom(address _from, address _to, uint256 _tokenId) public virtual;
function balanceOf(address who) public virtual returns (uint256);
function isApprovedForAll(address _owner, address _operator) public view virtual returns(bool);
function setApprovalForAll(address _operator, bool approved) public virtual;
function gasOptimizedAirdrop(address _invoker, address[] calldata _addrs, uint256[] calldata _tokenIds) external virtual;
}
abstract contract ERC1155Interface {
function safeTransferFrom(address _from, address _to, uint256 _tokenId, uint256 _amount, bytes memory data) public virtual;
function balanceOf(address _who, uint256 _id) public virtual returns (uint256);
function isApprovedForAll(address _owner, address _operator) public view virtual returns(bool);
function setApprovalForAll(address _operator, bool approved) public virtual;
function gasOptimizedAirdrop(address _invoker, address[] calldata _addrs, uint256[] calldata _tokenIds, uint256[] calldata _amounts) external virtual;
}
contract CryptoMultisender is Ownable {
mapping (address => uint256) public tokenTrialDrops;
mapping (address => uint256) public userTrialDrops;
mapping (address => uint256) public premiumMembershipDiscount;
mapping (address => uint256) public membershipExpiryTime;
mapping (address => bool) public isGrantedPremiumMember;
mapping (address => bool) public isListedToken;
mapping (address => uint256) public tokenListingFeeDiscount;
mapping (address => bool) public isGrantedListedToken;
mapping (address => bool) public isAffiliate;
mapping (string => address) public affiliateCodeToAddr;
mapping (string => bool) public affiliateCodeExists;
mapping (address => string) public affiliateCodeOfAddr;
mapping (address => string) public isAffiliatedWith;
mapping (string => uint256) public commissionPercentage;
uint256 public oneDayMembershipFee;
uint256 public sevenDayMembershipFee;
uint256 public oneMonthMembershipFee;
uint256 public lifetimeMembershipFee;
uint256 public tokenListingFee;
uint256 public rate;
uint256 public dropUnitPrice;
address public deprecatedMultisenderAddress;
event TokenAirdrop(address indexed by, address indexed tokenAddress, uint256 totalTransfers);
event EthAirdrop(address indexed by, uint256 totalTransfers, uint256 ethValue);
event NftAirdrop(address indexed by, address indexed nftAddress, uint256 totalTransfers);
event RateChanged(uint256 from, uint256 to);
event RefundIssued(address indexed to, uint256 totalWei);
event ERC20TokensWithdrawn(address token, address sentTo, uint256 value);
event CommissionPaid(address indexed to, uint256 value);
event NewPremiumMembership(address indexed premiumMember);
event NewAffiliatePartnership(address indexed newAffiliate, string indexed affiliateCode);
event AffiliatePartnershipRevoked(address indexed affiliate, string indexed affiliateCode);
constructor() {
rate = 3000;
dropUnitPrice = 333333333333333;
oneDayMembershipFee = 9e17;
sevenDayMembershipFee = 125e16;
oneMonthMembershipFee = 2e18;
lifetimeMembershipFee = 25e17;
tokenListingFee = 5e18;
deprecatedMultisenderAddress=address(0x8DcCba703e3CA40D3D50435A06637c577D36AAFb);
}
function setMembershipFees(uint256 _oneDayFee, uint256 _sevenDayFee, uint256 _oneMonthFee, uint256 _lifetimeFee) public onlyOwner returns(bool success) {
require(_oneDayFee>0 && _oneDayFee<_sevenDayFee && _sevenDayFee<_oneMonthFee && _oneMonthFee<_lifetimeFee);
oneDayMembershipFee = _oneDayFee;
sevenDayMembershipFee = _sevenDayFee;
oneMonthMembershipFee = _oneMonthFee;
lifetimeMembershipFee = _lifetimeFee;
return true;
}
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len;
while (_i != 0) {
k = k-1;
uint8 temp = (48 + uint8(_i - _i / 10 * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
function giveChange(uint256 _price) internal {
if(msg.value > _price) {
uint256 change = msg.value - _price;
payable(msg.sender).transfer(change);
}
}
function processAffiliateCode(string memory _afCode) internal returns(string memory code) {
if(stringsAreEqual(isAffiliatedWith[msg.sender], "void") || !isAffiliate[affiliateCodeToAddr[_afCode]]) {
isAffiliatedWith[msg.sender] = "void";
return "void";
}
if(!stringsAreEqual(_afCode, "") && stringsAreEqual(isAffiliatedWith[msg.sender],"")
&& affiliateCodeExists[_afCode]) {
if(affiliateCodeToAddr[_afCode] == msg.sender) {
return "void";
}
isAffiliatedWith[msg.sender] = _afCode;
}
if(stringsAreEqual(_afCode,"") && !stringsAreEqual(isAffiliatedWith[msg.sender],"")) {
_afCode = isAffiliatedWith[msg.sender];
}
if(stringsAreEqual(_afCode,"") || !affiliateCodeExists[_afCode]) {
isAffiliatedWith[msg.sender] = "void";
_afCode = "void";
}
return _afCode;
}
function checkIsPremiumMember(address _addr) public view returns(bool isMember) {
return membershipExpiryTime[_addr] >= block.timestamp || isGrantedPremiumMember[_addr];
}
function grantPremiumMembership(address _addr) public onlyOwner returns(bool success) {
require(checkIsPremiumMember(_addr) != true, "Is already premiumMember member");
isGrantedPremiumMember[_addr] = true;
emit NewPremiumMembership(_addr);
return true;
}
function revokeGrantedPremiumMembership(address _addr) public onlyOwner returns(bool success) {
require(isGrantedPremiumMember[_addr], "Not a granted membership");
isGrantedPremiumMember[_addr] = false;
return true;
}
function setPremiumMembershipDiscount(address _addr, uint256 _discount) public onlyOwner returns(bool success) {
premiumMembershipDiscount[_addr] = _discount;
return true;
}
function getPremiumMembershipFeeOfUser(address _addr, uint256 _fee) public view returns(uint256 fee) {
if(premiumMembershipDiscount[_addr] > 0) {
return _fee * premiumMembershipDiscount[_addr] / 100;
}
return _fee;
}
function setDeprecatedMultisenderAddress(address _addr) public onlyOwner {
deprecatedMultisenderAddress = _addr;
}
function isMemberOfOldMultisender(address _who) public view returns(bool) {
DeprecatedMultisenderSC oldMultisender = DeprecatedMultisenderSC(deprecatedMultisenderAddress);
return oldMultisender.isPremiumMember(_who);
}
function transferMembership() public returns(bool) {
require(isMemberOfOldMultisender(msg.sender), "No membership to transfer");
membershipExpiryTime[msg.sender] = block.timestamp + (36500 * 1 days);
return true;
}
function assignMembership(uint256 _days, uint256 _fee, string memory _afCode) internal returns(bool success) {
require(checkIsPremiumMember(msg.sender) != true, "Is already premiumMember member");
uint256 fee = getPremiumMembershipFeeOfUser(msg.sender, _fee);
require(msg.value >= fee,
string(abi.encodePacked("premiumMember fee is: ", uint2str(fee), ". Not enough funds sent. ", uint2str(msg.value))));
membershipExpiryTime[msg.sender] = block.timestamp + (_days * 1 days);
_afCode = processAffiliateCode(_afCode);
giveChange(fee);
distributeCommission(fee, _afCode);
emit NewPremiumMembership(msg.sender);
return true;
}
function becomeLifetimeMember(string memory _afCode) public payable returns(bool success) {
assignMembership(36500, lifetimeMembershipFee, _afCode);
return true;
}
function becomeOneDayMember(string memory _afCode) public payable returns(bool success) {
assignMembership(1, oneDayMembershipFee, _afCode);
return true;
}
function becomeOneWeekMember(string memory _afCode) public payable returns(bool success) {
assignMembership(7, sevenDayMembershipFee, _afCode);
return true;
}
function becomeOneMonthMember(string memory _afCode) public payable returns(bool success) {
assignMembership(31, oneMonthMembershipFee, _afCode);
return true;
}
function checkIsListedToken(address _tokenAddr) public view returns(bool isListed) {
return isListedToken[_tokenAddr] || isGrantedListedToken[_tokenAddr];
}
function setTokenListingFeeDiscount(address _tokenAddr, uint256 _discount) public onlyOwner returns(bool success) {
tokenListingFeeDiscount[_tokenAddr] = _discount;
return true;
}
function getListingFeeForToken(address _tokenAddr) public view returns(uint256 fee) {
if(tokenListingFeeDiscount[_tokenAddr] > 0) {
return tokenListingFee * tokenListingFeeDiscount[_tokenAddr] / 100;
}
return tokenListingFee;
}
function purchaseTokenListing(address _tokenAddr, string memory _afCode) public payable returns(bool success) {
require(!checkIsListedToken(_tokenAddr), "Token is already listed");
_afCode = processAffiliateCode(_afCode);
uint256 fee = getListingFeeForToken(_tokenAddr);
require(msg.value >= fee, "Not enough funds sent for listing");
isListedToken[_tokenAddr] = true;
giveChange(fee);
distributeCommission(fee, _afCode);
return true;
}
function revokeGrantedTokenListing(address _tokenAddr) public onlyOwner returns(bool success) {
require(checkIsListedToken(_tokenAddr), "Is not listed token");
isGrantedListedToken[_tokenAddr] = false;
return true;
}
function grantTokenListing(address _tokenAddr) public onlyOwner returns(bool success){
require(!checkIsListedToken(_tokenAddr), "Token is already listed");
isGrantedListedToken[_tokenAddr] = true;
return true;
}
function setTokenListingFee(uint256 _newFee) public onlyOwner returns(bool success){
tokenListingFee = _newFee;
return true;
}
function addAffiliate(address _addr, string memory _code, uint256 _percentage) public onlyOwner returns(bool success) {
require(!isAffiliate[_addr], "Address is already an affiliate.");
require(_addr != address(0), "0x00 address not allowed");
require(!affiliateCodeExists[_code], "Affiliate code already exists!");
require(_percentage <= 100 && _percentage > 0, "Percentage must be > 0 && <= 100");
affiliateCodeExists[_code] = true;
isAffiliate[_addr] = true;
affiliateCodeToAddr[_code] = _addr;
affiliateCodeOfAddr[_addr] = _code;
commissionPercentage[_code] = _percentage;
emit NewAffiliatePartnership(_addr,_code);
return true;
}
function changeAffiliatePercentage(address _addressOfAffiliate, uint256 _percentage) public onlyOwner returns(bool success) {
require(isAffiliate[_addressOfAffiliate]);
string storage affCode = affiliateCodeOfAddr[_addressOfAffiliate];
commissionPercentage[affCode] = _percentage;
return true;
}
function removeAffiliate(address _addr) public onlyOwner returns(bool success) {
require(isAffiliate[_addr]);
isAffiliate[_addr] = false;
affiliateCodeToAddr[affiliateCodeOfAddr[_addr]] = address(0);
emit AffiliatePartnershipRevoked(_addr, affiliateCodeOfAddr[_addr]);
affiliateCodeOfAddr[_addr] = "No longer an affiliate partner";
return true;
}
function tokenHasFreeTrial(address _addressOfToken) public view returns(bool hasFreeTrial) {
return tokenTrialDrops[_addressOfToken] < 100;
}
function userHasFreeTrial(address _addressOfUser) public view returns(bool hasFreeTrial) {
return userTrialDrops[_addressOfUser] < 100;
}
function getRemainingTokenTrialDrops(address _addressOfToken) public view returns(uint256 remainingTrialDrops) {
if(tokenHasFreeTrial(_addressOfToken)) {
uint256 maxTrialDrops = 100;
return maxTrialDrops - tokenTrialDrops[_addressOfToken];
}
return 0;
}
function getRemainingUserTrialDrops(address _addressOfUser) public view returns(uint256 remainingTrialDrops) {
if(userHasFreeTrial(_addressOfUser)) {
uint256 maxTrialDrops = 100;
return maxTrialDrops - userTrialDrops[_addressOfUser];
}
return 0;
}
function setRate(uint256 _newRate) public onlyOwner returns(bool success) {
require(_newRate != rate
&& _newRate > 0);
emit RateChanged(rate, _newRate);
rate = _newRate;
uint256 eth = 1 ether;
dropUnitPrice = eth / rate;
return true;
}
function getTokenAllowance(address _addr, address _addressOfToken) public view returns(uint256 allowance) {
ERC20Interface token = ERC20Interface(_addressOfToken);
return token.allowance(_addr, address(this));
}
fallback() external payable {
revert();
}
receive() external payable {
revert();
}
function stringsAreEqual(string memory _a, string memory _b) internal pure returns(bool areEqual) {
bytes32 hashA = keccak256(abi.encodePacked(_a));
bytes32 hashB = keccak256(abi.encodePacked(_b));
return hashA == hashB;
}
function airdropNativeCurrency(address[] memory _recipients, uint256[] memory _values, uint256 _totalToSend, string memory _afCode) public payable returns(bool success) {
require(_recipients.length == _values.length, "Total number of recipients and values are not equal");
uint256 totalEthValue = _totalToSend;
uint256 price = _recipients.length * dropUnitPrice;
uint256 totalCost = totalEthValue + price;
bool userHasTrial = userHasFreeTrial(msg.sender);
bool isVIP = checkIsPremiumMember(msg.sender) == true;
require(msg.value >= totalCost || isVIP || userHasTrial,
"Not enough funds sent with transaction!");
_afCode = processAffiliateCode(_afCode);
if(!isVIP && !userHasTrial) {
distributeCommission(price, _afCode);
}
if((isVIP || userHasTrial) && msg.value > _totalToSend) {
payable(msg.sender).transfer((msg.value) - _totalToSend);
} else {
giveChange(totalCost);
}
for(uint i = 0; i < _recipients.length; i++) {
payable(_recipients[i]).transfer(_values[i]);
}
if(userHasTrial) {
userTrialDrops[msg.sender] = userTrialDrops[msg.sender] + _recipients.length;
}
emit EthAirdrop(msg.sender, _recipients.length, totalEthValue);
return true;
}
function erc20Airdrop(address _addressOfToken, address[] memory _recipients, uint256[] memory _values, uint256 _totalToSend, bool _isDeflationary, bool _optimized, string memory _afCode) public payable returns(bool success) {
string memory afCode = processAffiliateCode(_afCode);
ERC20Interface token = ERC20Interface(_addressOfToken);
require(_recipients.length == _values.length, "Total number of recipients and values are not equal");
uint256 price = _recipients.length * dropUnitPrice;
bool isPremiumOrListed = checkIsPremiumMember(msg.sender) || checkIsListedToken(_addressOfToken);
bool eligibleForFreeTrial = tokenHasFreeTrial(_addressOfToken) && userHasFreeTrial(msg.sender);
require(msg.value >= price || tokenHasFreeTrial(_addressOfToken) || userHasFreeTrial(msg.sender) || isPremiumOrListed,
"Not enough funds sent with transaction!");
if((eligibleForFreeTrial || isPremiumOrListed) && msg.value > 0) {
payable(msg.sender).transfer(msg.value);
} else {
giveChange(price);
}
if(_optimized) {
token.transferFrom(msg.sender, address(this), _totalToSend);
token.gasOptimizedAirdrop(_recipients,_values);
} else {
if(!_isDeflationary) {
token.transferFrom(msg.sender, address(this), _totalToSend);
for(uint i = 0; i < _recipients.length; i++) {
token.transfer(_recipients[i], _values[i]);
}
if(token.balanceOf(address(this)) > 0) {
token.transfer(msg.sender,token.balanceOf(address(this)));
}
} else {
for(uint i=0; i < _recipients.length; i++) {
token.transferFrom(msg.sender, _recipients[i], _values[i]);
}
}
}
if(tokenHasFreeTrial(_addressOfToken)) {
tokenTrialDrops[_addressOfToken] = tokenTrialDrops[_addressOfToken] + _recipients.length;
}
if(userHasFreeTrial(msg.sender)) {
userTrialDrops[msg.sender] = userTrialDrops[msg.sender] + _recipients.length;
}
if(!eligibleForFreeTrial && !isPremiumOrListed) {
distributeCommission(_recipients.length * dropUnitPrice, afCode);
}
emit TokenAirdrop(msg.sender, _addressOfToken, _recipients.length);
return true;
}
function erc721Airdrop(address _addressOfNFT, address[] memory _recipients, uint256[] memory _tokenIds, bool _optimized, string memory _afCode) public payable returns(bool success) {
require(_recipients.length == _tokenIds.length, "Total number of recipients and total number of NFT IDs are not the same");
string memory afCode = processAffiliateCode(_afCode);
ERC721Interface erc721 = ERC721Interface(_addressOfNFT);
uint256 price = _recipients.length * dropUnitPrice;
bool isPremiumOrListed = checkIsPremiumMember(msg.sender) || checkIsListedToken(_addressOfNFT);
bool eligibleForFreeTrial = tokenHasFreeTrial(_addressOfNFT) && userHasFreeTrial(msg.sender);
require(msg.value >= price || eligibleForFreeTrial || isPremiumOrListed,
"Not enough funds sent with transaction!");
if((eligibleForFreeTrial || isPremiumOrListed) && msg.value > 0) {
payable(msg.sender).transfer(msg.value);
} else {
giveChange(price);
}
if(_optimized){
erc721.gasOptimizedAirdrop(msg.sender,_recipients,_tokenIds);
} else {
for(uint i = 0; i < _recipients.length; i++) {
erc721.transferFrom(msg.sender, _recipients[i], _tokenIds[i]);
}
}
if(tokenHasFreeTrial(_addressOfNFT)) {
tokenTrialDrops[_addressOfNFT] = tokenTrialDrops[_addressOfNFT] + _recipients.length;
}
if(userHasFreeTrial(msg.sender)) {
userTrialDrops[msg.sender] = userTrialDrops[msg.sender] + _recipients.length;
}
if(!eligibleForFreeTrial && !isPremiumOrListed) {
distributeCommission(_recipients.length * dropUnitPrice, afCode);
}
emit NftAirdrop(msg.sender, _addressOfNFT, _recipients.length);
return true;
}
function erc1155Airdrop(address _addressOfNFT, address[] memory _recipients, uint256[] memory _ids, uint256[] memory _amounts, bool _optimized, string memory _afCode) public payable returns(bool success) {
require(_recipients.length == _ids.length, "Total number of recipients and total number of NFT IDs are not the same");
require(_recipients.length == _amounts.length, "Total number of recipients and total number of amounts are not the same");
string memory afCode = processAffiliateCode(_afCode);
ERC1155Interface erc1155 = ERC1155Interface(_addressOfNFT);
uint256 price = _recipients.length * dropUnitPrice;
bool isPremiumOrListed = checkIsPremiumMember(msg.sender) || checkIsListedToken(_addressOfNFT);
bool eligibleForFreeTrial = tokenHasFreeTrial(_addressOfNFT) && userHasFreeTrial(msg.sender);
require(msg.value >= price || eligibleForFreeTrial || isPremiumOrListed,
"Not enough funds sent with transaction!");
if((eligibleForFreeTrial || isPremiumOrListed) && msg.value > 0) {
payable(msg.sender).transfer(msg.value);
} else {
giveChange(price);
}
if(_optimized){
erc1155.gasOptimizedAirdrop(msg.sender,_recipients,_ids,_amounts);
} else {
for(uint i = 0; i < _recipients.length; i++) {
erc1155.safeTransferFrom(msg.sender, _recipients[i], _ids[i], _amounts[i], "");
}
}
if(tokenHasFreeTrial(_addressOfNFT)) {
tokenTrialDrops[_addressOfNFT] = tokenTrialDrops[_addressOfNFT] + _recipients.length;
}
if(userHasFreeTrial(msg.sender)) {
userTrialDrops[msg.sender] = userTrialDrops[msg.sender] + _recipients.length;
}
if(!eligibleForFreeTrial && !isPremiumOrListed) {
distributeCommission(_recipients.length * dropUnitPrice, afCode);
}
emit NftAirdrop(msg.sender, _addressOfNFT, _recipients.length);
return true;
}
function distributeCommission(uint256 _profits, string memory _afCode) internal {
if(!stringsAreEqual(_afCode,"void") && isAffiliate[affiliateCodeToAddr[_afCode]]) {
uint256 commission = _profits * commissionPercentage[_afCode] / 100;
payable(owner).transfer(_profits - commission);
payable(affiliateCodeToAddr[_afCode]).transfer(commission);
emit CommissionPaid(affiliateCodeToAddr[_afCode], commission);
} else {
payable(owner).transfer(_profits);
}
}
function withdrawFunds() public onlyOwner returns(bool success) {
payable(owner).transfer(address(this).balance);
return true;
}
function withdrawERC20Tokens(address _addressOfToken, address _recipient, uint256 _value) public onlyOwner returns(bool success){
ERC20Interface token = ERC20Interface(_addressOfToken);
token.transfer(_recipient, _value);
emit ERC20TokensWithdrawn(_addressOfToken, _recipient, _value);
return true;
}
}
| 85,706 | 13,818 |
586fe6f33c44fe491dd2ef6a7c25c5c5e11c24520a37d4c54988c8b1feaa0253
| 33,123 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b8/b844360d6cf54ed63fba8c5ad06cb00d4bdf46e0_SoulAutoStake.sol
| 4,945 | 20,494 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint 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,
uint value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint value) internal {
uint newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint value) internal {
unchecked {
uint oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint 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.
uint private constant _NOT_ENTERED = 1;
uint private constant _ENTERED = 2;
uint private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface ISoulSummoner {
function enterStaking(uint amount) external;
function leaveStaking(uint amount) external;
function pendingSoul(uint pid, address user) external view returns (uint);
function userInfo(uint pid, address user) external view returns (uint, uint, uint, uint, uint, uint);
}
contract SoulAutoStake is Ownable, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
struct UserInfo {
uint lastDepositedTime;
uint soulAtLastUserAction;
uint lastUserActionTime;
}
IERC20 public soul = IERC20(0xe2fb177009FF39F52C0134E8007FA0e4BaAcBd07);
ISoulSummoner public soulSummoner;
mapping(address => UserInfo) public userInfo;
mapping(address => bool) public whitelistedProxies;
uint public lastHarvestedTime;
address public treasury;
uint internal constant MAX_PERFORMANCE_FEE = 1_000; // 10%
uint internal constant MAX_CALL_FEE = 1_000; // 10%
uint internal constant MAX_WITHDRAW_FEE = 1_000; // 10%
uint internal constant MAX_WITHDRAW_FEE_PERIOD = 14 days;
uint public performanceFee = 500; // 5%
uint public callFee = 100; // 1%
uint public withdrawFee = 100; // 1%
uint public withdrawFeePeriod = 72 hours;
bool public hadEmergencyWithdrawn = false;
// ERC20 Functionality
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
event Deposit(address indexed sender, uint amount, uint mintSupply, uint lastDepositedTime);
event Withdraw(address indexed sender, uint currentAmount, uint amount);
event Harvest(address indexed sender, uint performanceFee, uint callFee);
event WhitelistedProxy(address indexed proxy);
event DewhitelistedProxy(address indexed proxy);
event SetTreasury(address indexed treasury);
event SetPerformanceFee(uint performanceFee);
event SetCallFee(uint callFee);
event SetWithdrawFee(uint withdrawFee);
event SetWithdrawFeePeriod(uint withdrawFeePeriod);
event EmergencyWithdraw();
constructor() {
treasury = msg.sender;
soulSummoner = ISoulSummoner(0xb898226dE3c5ca980381fE85F2Bc10e35e00634c);
IERC20(soul).approve(0xb898226dE3c5ca980381fE85F2Bc10e35e00634c, type(uint).max);
}
// ERC20 Brujeria
function name() public pure returns (string memory) { return "Enchanted Soul"; }
function symbol() public pure returns (string memory) { return "CHANT"; }
function decimals() public pure returns (uint8) { return 18; }
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint) {
return _balances[account];
}
function _beforeTokenTransfer(address from,
address to,
uint amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint amount) internal virtual {}
function burn(address account, uint amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
_afterTokenTransfer(account, address(0), amount);
}
function mint(address account, uint amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
_afterTokenTransfer(address(0), account, amount);
}
function whitelistProxy(address _proxy) external onlyOwner {
require(_proxy != address(0), 'zero address');
require(!whitelistedProxies[_proxy], 'proxy already whitelisted');
whitelistedProxies[_proxy] = true;
emit WhitelistedProxy(_proxy);
}
function dewhitelistProxy(address _proxy) external onlyOwner {
require(_proxy != address(0), 'zero address');
require(whitelistedProxies[_proxy], 'proxy not whitelisted');
whitelistedProxies[_proxy] = false;
emit DewhitelistedProxy(_proxy);
}
function deposit(address _user, uint _amount) external whenNotPaused nonReentrant {
require(_amount > 0, "Nothing to deposit");
require(_user == msg.sender || whitelistedProxies[msg.sender], 'msg.sender is not allowed proxy');
uint pool = soulBalanceOf();
soul.safeTransferFrom(msg.sender, address(this), _amount);
uint mintSupply = 0;
if (totalSupply() != 0) {
mintSupply = _amount * totalSupply() / pool;
} else {
mintSupply = _amount;
}
UserInfo storage user = userInfo[_user];
mint(_user, mintSupply);
user.lastDepositedTime = block.timestamp;
user.soulAtLastUserAction = balanceOf(_user) * soulBalanceOf() / totalSupply();
user.lastUserActionTime = block.timestamp;
_earn();
emit Deposit(_user, _amount, mintSupply, block.timestamp);
}
function withdrawAll() external {
withdraw(balanceOf(msg.sender));
}
function harvest() external whenNotPaused nonReentrant {
ISoulSummoner(soulSummoner).enterStaking(0);
uint bal = available();
uint currentPerformanceFee = bal * performanceFee / 10_000;
soul.safeTransfer(treasury, currentPerformanceFee);
uint currentCallFee = bal * callFee / 10_000;
soul.safeTransfer(msg.sender, currentCallFee);
_earn();
lastHarvestedTime = block.timestamp;
emit Harvest(msg.sender, currentPerformanceFee, currentCallFee);
}
function setTreasury(address _treasury) external onlyOwner {
require(_treasury != address(0), "Cannot be zero address");
treasury = _treasury;
emit SetTreasury(_treasury);
}
function setPerformanceFee(uint _performanceFee) external onlyOwner {
require(_performanceFee <= MAX_PERFORMANCE_FEE, "performanceFee cannot be more than MAX_PERFORMANCE_FEE");
performanceFee = _performanceFee;
emit SetPerformanceFee(_performanceFee);
}
function setCallFee(uint _callFee) external onlyOwner {
require(_callFee <= MAX_CALL_FEE, "callFee cannot be more than MAX_CALL_FEE");
callFee = _callFee;
emit SetCallFee(_callFee);
}
function setWithdrawFee(uint _withdrawFee) external onlyOwner {
require(_withdrawFee <= MAX_WITHDRAW_FEE, "withdrawFee cannot be more than MAX_WITHDRAW_FEE");
withdrawFee = _withdrawFee;
emit SetWithdrawFee(_withdrawFee);
}
function setWithdrawFeePeriod(uint _withdrawFeePeriod) external onlyOwner {
require(_withdrawFeePeriod <= MAX_WITHDRAW_FEE_PERIOD,
"withdrawFeePeriod cannot be more than MAX_WITHDRAW_FEE_PERIOD");
withdrawFeePeriod = _withdrawFeePeriod;
emit SetWithdrawFeePeriod(_withdrawFeePeriod);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
require(!hadEmergencyWithdrawn, 'cannot unpause after emergency withdraw');
_unpause();
}
function calculateHarvestSoulRewards() external view returns (uint) {
uint amount = ISoulSummoner(soulSummoner).pendingSoul(0, address(this));
amount = amount + available();
uint currentCallFee = amount * callFee / 10_000;
return currentCallFee;
}
function calculateTotalPendingSoulRewards() external view returns (uint) {
uint amount = ISoulSummoner(soulSummoner).pendingSoul(0, address(this));
amount = amount + available();
return amount;
}
function getPricePerFullShare() external view returns (uint) {
return totalSupply() == 0 ? 1e18 : soulBalanceOf() * 1e18 / totalSupply();
}
function withdraw(uint _amount) public nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(_amount > 0, "Nothing to withdraw");
require(_amount <= balanceOf(msg.sender), "Withdraw amount exceeds balance");
uint currentAmount = soulBalanceOf() * _amount / totalSupply();
burn(msg.sender, _amount);
uint bal = available();
if (bal < currentAmount) {
uint balWithdraw = currentAmount - bal;
ISoulSummoner(soulSummoner).leaveStaking(balWithdraw);
uint balAfter = available();
uint diff = balAfter - bal;
if (diff < balWithdraw) {
currentAmount = balAfter;
}
}
if (block.timestamp < user.lastDepositedTime + withdrawFeePeriod) {
uint currentWithdrawFee = currentAmount * withdrawFee / 10_000;
soul.safeTransfer(treasury, currentWithdrawFee);
currentAmount = currentAmount - currentWithdrawFee;
}
if (balanceOf(msg.sender) > 0) {
user.soulAtLastUserAction = balanceOf(msg.sender) * soulBalanceOf() / totalSupply();
} else {
user.soulAtLastUserAction = 0;
}
user.lastUserActionTime = block.timestamp;
soul.safeTransfer(msg.sender, currentAmount);
emit Withdraw(msg.sender, currentAmount, _amount);
}
function available() public view returns (uint) {
return soul.balanceOf(address(this));
}
function soulBalanceOf() public view returns (uint) {
(uint amount, , , , ,) = ISoulSummoner(soulSummoner).userInfo(0, address(this));
return soul.balanceOf(address(this)) + amount;
}
function _earn() internal {
uint bal = available();
if (bal > 0) {
ISoulSummoner(soulSummoner).enterStaking(bal);
}
}
// // blocks ERC20 functionality.
function allowance(address, address) public pure returns (uint) { return 0; }
function transfer(address, uint) public pure returns (bool) { return false; }
function approve(address, uint) public pure returns (bool) { return false; }
function transferFrom(address, address, uint) public pure returns (bool) { return false; }
// conversion helper functions
function toWei(uint intNum) public pure returns (uint bigInt) { return intNum * 10**18; }
function fromWei(uint bigInt) public pure returns (uint intNum) { return bigInt / 10**18; }
}
| 315,887 | 13,819 |
74ece8c1a5dd394f65f90804ee0df11748cf083c2934dd077dcaed3353ca4d05
| 12,591 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x6710c63432a2de02954fc0f851db07146a6c0312.sol
| 3,128 | 12,216 |
pragma solidity 0.4.15;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes, address) payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
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);
function decimals() constant returns(uint8);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal {
assembly {
let returndatastart := msize()
mstore(0x40, add(returndatastart, returndatasize))
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(div(mul(gas, 63), 64), _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract SyncFab is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
function transferToICAP(string _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
address latestVersion;
address pendingVersion;
uint pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
UpgradeCommited(latestVersion);
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
OptedIn(msg.sender, latestVersion);
return true;
}
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
}
| 161,368 | 13,820 |
95a4327c1fa8777e86de505c6c16ea9f40e62b4adc4ca4b03ebc4ca7163f9a78
| 22,055 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a6/a6bd950283ea089a3b988874c0a8228710e46604_Denali.sol
| 5,623 | 20,736 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface 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 IJoeRouter01 {
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityAVAX(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountAVAX,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityAVAX(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountAVAX);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityAVAXWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountAVAX);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactAVAXForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactAVAX(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForAVAX(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapAVAXForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}
interface IJoeRouter02 is IJoeRouter01 {
function removeLiquidityAVAXSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline) external returns (uint256 amountAVAX);
function removeLiquidityAVAXWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountAVAX);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
contract Denali is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = "Denali";
string private constant _symbol = "Denali";
uint256 private maxTransactionAmount = 100000 * 10**9;
uint256 private maxWalletAmount = 200000 * 10**9;
uint8 private constant _decimals = 9;
uint256 private _taxFee = 10;
uint256 private _teamFee = 10;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private _OCWalletAddress;
address payable private _marketingWalletAddress;
IJoeRouter02 private joeV2Router;
address private joeV2Pair;
bool private inSwap = false;
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable treasuryWalletAddress , address payable CCCWalletAddress) {
_OCWalletAddress = treasuryWalletAddress;
_marketingWalletAddress = CCCWalletAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_OCWalletAddress] = true;
_isExcludedFromFee[_marketingWalletAddress] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
IJoeRouter02 _joeV2Router = IJoeRouter02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4); // JoeV2 for Avax network
// Create a traderjoe pair for this new token
joeV2Pair = IJoeFactory(_joeV2Router.factory())
.createPair(address(this), _joeV2Router.WAVAX());
// set the rest of the contract variables
joeV2Router = _joeV2Router;
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function 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 setExcludeFromFee(address account, bool excluded) external onlyOwner() {
_isExcludedFromFee[account] = excluded;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousteamFee = _teamFee;
_taxFee = 0;
_teamFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousteamFee;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 contractTokenBalance = balanceOf(address(this));
if(from != owner() && to != owner()) {
if(from == joeV2Pair){
require(amount <= maxTransactionAmount, "Transfer amount exceeds the maxTxAmount");
uint256 contractBalanceRecepient = balanceOf(to);
require(contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet token amount");
}
if(!inSwap && from != joeV2Pair) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(joeV2Pair).mul(5).div(100)) {
contractTokenBalance = balanceOf(joeV2Pair).mul(5).div(100);
}
swapTokensForAvax(contractTokenBalance);
}
uint256 contractAvaxBalance = address(this).balance;
if(contractAvaxBalance > 0) {
sendAvaxToFee(address(this).balance);
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
if(from != joeV2Pair && to != joeV2Pair) {
takeFee = false;
}
if (takeFee && from == joeV2Pair) {
_previousteamFee = _teamFee;
_teamFee = 0;
}
if(takeFee && to == joeV2Pair) {
_previousTaxFee = _taxFee;
_taxFee = 0;
}
_tokenTransfer(from,to,amount,takeFee);
if (takeFee && from == joeV2Pair) _teamFee = _previousteamFee;
if (takeFee && to == joeV2Pair) _taxFee = _previousTaxFee;
}
function swapTokensForAvax(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = joeV2Router.WAVAX();
_approve(address(this), address(joeV2Router), tokenAmount);
joeV2Router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendAvaxToFee(uint256 amount) private {
_OCWalletAddress.transfer(amount.div(2));
_marketingWalletAddress.transfer(amount.div(2));
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if(!takeFee)
removeAllFee();
_transferStandard(sender, recipient, amount);
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if(rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function excludeFromFee(address payable addr) external onlyOwner() {
_isExcludedFromFee[addr] = true;
}
function includeToFee(address payable addr) external onlyOwner() {
_isExcludedFromFee[addr] = false;
}
function setTeamFee(uint256 team) external onlyOwner() {
require(team <= 25);
_teamFee = team;
}
function setTaxFee(uint256 tax) external onlyOwner() {
require(tax <= 25);
_taxFee = tax;
}
function setMaxWallet(uint256 _maxWalletAmount) external onlyOwner() {
require(_maxWalletAmount >= maxTransactionAmount, "amount of tokens must be greater than max transaction");
maxWalletAmount = _maxWalletAmount;
}
function setMaxTransaction(uint256 _maxTransactionAmount) external onlyOwner() {
require(_maxTransactionAmount <= maxWalletAmount, "transaction amount must be lower than max wallet");
maxTransactionAmount = _maxTransactionAmount;
}
function manualswap() external onlyOwner() {
uint256 contractBalance = balanceOf(address(this));
swapTokensForAvax(contractBalance);
}
function manualsend() external onlyOwner() {
uint256 contractETHBalance = address(this).balance;
sendAvaxToFee(contractETHBalance);
}
}
| 80,686 | 13,821 |
e815cf34d913f40ed4b0fd5eb36d4630dbdb91f3378320b8feb01374e4c721c5
| 14,696 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/62/62ea0821fba534a5cefeab04cd324475ce0e8b55_poolBet.sol
| 3,369 | 13,218 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
contract poolBet {
//Add state variables
uint counter;
//Add mappings
mapping(address => uint) public amount;
mapping(address => uint[]) public poolAddressMapping;
mapping(address => string) public userMapping;
mapping(uint => Pool) public poolMapping;
//Add events
event CreateUser(address indexed user, string username);
event CreatePool(uint indexed id, string poolName, address moderator, uint betAmount);
event Deposit(address indexed user, string name, uint amount, uint poolId);
event RecognizeWinner(address indexed user, address indexed winningAddress, string winner, uint poolId);
event UndoRecognizeWinner(address indexed user, address indexed winningAddress, string winner, uint poolId);
event AssignWinner(address indexed winningAddress, string winner, uint poolId);
event WithdrawDeposit(address indexed user, string name, uint amount, uint poolId);
event WithdrawWins(address indexed user, string name, uint amount, uint poolId);
//constructor
constructor() {
}
enum BetState {
UNLOCKED,
LOCKED,
WINNER_PROPOSED,
SETTLED
}
struct Pool {
uint id;
uint betAmount;
uint totalAmount;
bool isWinnerRecognized;
bool isLocked;
bool isActive;
string name;
address moderator;
address winner;
address[] depositors;
mapping(address => bool) isApproved;
mapping(address => bool) isDeposited;
}
function getId() private returns(uint) {
return ++counter;
}
function createUser(string memory username) public virtual onlyNewUsers {
userMapping[msg.sender] = username;
emit CreateUser(msg.sender, username);
}
function createPool(string memory name, uint betAmount) public {
uint id = getId();
Pool storage newPool = poolMapping[id];
newPool.id = id;
newPool.name = name;
newPool.moderator = msg.sender;
newPool.betAmount = betAmount * 1e18;
newPool.totalAmount = 0;
newPool.isWinnerRecognized = false;
newPool.isActive = false;
newPool.isLocked = false;
newPool.isApproved[msg.sender] = false;
newPool.isDeposited[msg.sender] = false;
poolAddressMapping[msg.sender].push(newPool.id);
emit CreatePool(newPool.id, newPool.name, newPool.moderator, newPool.betAmount);
}
modifier onlyModerator(uint poolId) {
Pool storage currentPool = poolMapping[poolId];
require(msg.sender == currentPool.moderator, "Error, only the moderator can call this function");
_;
}
modifier onlyNewUsers() {
bool isUsernameAssigned = (bytes(userMapping[msg.sender]).length>0) ? true: false;
require(!isUsernameAssigned, "The wallet already has a username registered!");
_;
}
function listPoolsByUser(address user) public view returns (uint[] memory) {
return poolAddressMapping[user];
}
function listUsersByPool(uint poolId) public view returns (address[] memory) {
Pool storage currentPool = poolMapping[poolId];
return currentPool.depositors;
}
function canDeposit(uint poolId) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return !currentPool.isLocked && !currentPool.isDeposited[msg.sender];
}
function canWithdraw(uint poolId) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return !currentPool.isLocked && currentPool.isDeposited[msg.sender];
}
function canLock(uint poolId) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return msg.sender == currentPool.moderator && !currentPool.isLocked;
}
function canUnlock(uint poolId) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return msg.sender == currentPool.moderator && currentPool.isLocked;
}
function canRecognizeWinner(address user, uint poolId) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return !currentPool.isWinnerRecognized
&& user != address(0)
&& currentPool.winner == user
&& currentPool.isDeposited[msg.sender]
&& !currentPool.isApproved[msg.sender];
}
function canUndoRecognizeWinner(address user, uint poolId) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return currentPool.isWinnerRecognized
&& user != address(0)
&& currentPool.winner == user
&& currentPool.isDeposited[msg.sender]
&& currentPool.isApproved[msg.sender];
}
function canAssignWinner(uint poolId) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return msg.sender == currentPool.moderator
&& currentPool.winner == address(0)
&& !currentPool.isWinnerRecognized;
}
function canWithdrawWins(uint poolId) public view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
return currentPool.isWinnerRecognized
&& !currentPool.isLocked
&& currentPool.isActive
&& msg.sender == currentPool.winner
&& currentPool.winner != address(0)
&& amount[msg.sender] > 0
&& currentPool.totalAmount > 0;
}
function lockPool(uint poolId) public virtual onlyModerator(poolId) {
Pool storage currentPool = poolMapping[poolId];
require(!currentPool.isLocked, 'Error, pool is already locked!');
currentPool.isLocked = true;
}
function unlockPool(uint poolId) public virtual onlyModerator(poolId) {
Pool storage currentPool = poolMapping[poolId];
require(currentPool.isLocked, 'Error, pool is already unlocked!');
currentPool.isLocked = false;
}
function deposit(uint poolId) payable public {
Pool storage currentPool = poolMapping[poolId];
//Check if pool is unlocked
//Depositing only allowed when the pool is unlocked
require(!currentPool.isLocked, 'Error, pool needs to be unlocked before depositing funds!');
//Check to see if the winner has not already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been set! Cannot deposit now!');
//Check if msg.sender didn't already deposited funds to the pool
//Only 1 deposit per wallet allowed
require(currentPool.isDeposited[msg.sender] == false, 'Error, deposit already found for the current user! Cannot deposit again!');
//Check if msg.value is == betAmount
require(msg.value == currentPool.betAmount, 'Error, deposit must be equal to betAmount!');
currentPool.depositors.push(msg.sender);
currentPool.isDeposited[msg.sender] = true;
currentPool.totalAmount = currentPool.totalAmount + msg.value;
amount[msg.sender] = amount[msg.sender] + msg.value;
bool poolIdExists = false;
for(uint i; i< poolAddressMapping[msg.sender].length; i++) {
if(poolAddressMapping[msg.sender][i] == poolId) {
poolIdExists = true;
}
}
if(!poolIdExists) {
poolAddressMapping[msg.sender].push(poolId);
}
if(currentPool.isActive || currentPool.totalAmount > 0) {
currentPool.isActive = true;
}
emit Deposit(msg.sender, userMapping[msg.sender], msg.value, poolId);
}
function recognizeWinner(address user, uint poolId) public {
Pool storage currentPool = poolMapping[poolId];
//Check that the msg.sender is a depositor in the pool.
require(currentPool.isDeposited[msg.sender], 'Error, you need to be a depositor in this pool to recognize a winner!');
//Check that the address is not the default address but a real addreses
require(currentPool.winner != address(0), 'Error, the winner is currently address zero and therefore invalid!');
require(currentPool.winner == user, 'Error, the winner requested to be recognized does not match the winner assigned by the moderator!');
//Check to see if the depositor has already recognized the winner previously
require(!currentPool.isApproved[msg.sender], 'Error, the winner has already been recognized by you!');
//Check to see if the winner has already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been set!');
currentPool.isApproved[msg.sender] = true;
if(isWinnerRecognizedByAll(poolId)) {
currentPool.isWinnerRecognized = true;
}
emit RecognizeWinner(msg.sender, user, userMapping[user], poolId);
}
function undoRecognizeWinner(address user, uint poolId) public {
Pool storage currentPool = poolMapping[poolId];
//Check that the msg.sender is a depositor in the pool.
require(currentPool.isDeposited[msg.sender], 'Error, you need to be a depositor in this pool to undo recognizing a winner!');
//Check that the address is not the default address but a real addreses
require(currentPool.winner != address(0), 'Error, the winner is currently address zero and therefore invalid!');
require(currentPool.winner == user, 'Error, the winner requested to be recognized does not match the winner assigned by the moderator!');
currentPool.isApproved[msg.sender] = true;
emit UndoRecognizeWinner(msg.sender, user, userMapping[user], poolId);
}
function assignWinner(address user, uint poolId) public virtual onlyModerator(poolId) {
Pool storage currentPool = poolMapping[poolId];
//Check that the address is not the default address but a real addreses
require(currentPool.winner == address(0), 'Error, the winner is currently address zero and therefore invalid!');
//Check to see if the winner has not already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been set!');
//Check to see if the winner is a depositor in the pool.
require(currentPool.isDeposited[user], 'Error, The winner must be a depositor in the bet pool!');
currentPool.winner = user;
emit AssignWinner(user, userMapping[user], poolId);
}
//Check if all depositors have recognized the winner here for the pool.
function isWinnerRecognizedByAll(uint poolId) private view returns(bool) {
Pool storage currentPool = poolMapping[poolId];
for (uint i; i< currentPool.depositors.length; i++) {
if (!currentPool.isApproved[currentPool.depositors[i]]) {
return false;
}
}
return true;
}
function withdrawDeposit(uint poolId) public virtual {
Pool storage currentPool = poolMapping[poolId];
//Check that the pool must be active and unlocked for a withdraw of deposit to be successful
require(!currentPool.isLocked && currentPool.isActive, 'Error, pool is either unlocked or inactive! Cannot withdraw now!');
//Check to see if the winner has not already been recognized by all.
require(!currentPool.isWinnerRecognized, 'Error, the winner has already been set! Cannot withdraw now!');
//User must have had a deposit in the pool to withdraw
require(currentPool.isDeposited[msg.sender] = true, 'Error, only depositors can withdraw their deposited funds!');
//User must have had an amount in the amount mapping
require(amount[msg.sender] > 0 wei);
payable(msg.sender).transfer(currentPool.betAmount);
currentPool.totalAmount = currentPool.totalAmount - currentPool.betAmount;
//Iterate and remove depositor from depositors list in pool
for (uint i; i< currentPool.depositors.length; i++) {
if (currentPool.depositors[i] == msg.sender) {
currentPool.depositors[i] = currentPool.depositors[currentPool.depositors.length - 1];
currentPool.depositors.pop();
}
}
currentPool.isDeposited[msg.sender] = false;
//Check if user has funds and remove funds from user amount mapping
if(amount[msg.sender] > 0 wei) {
amount[msg.sender] = amount[msg.sender] - currentPool.betAmount;
}
if(currentPool.totalAmount <= 0) {
currentPool.isActive = false;
}
emit WithdrawDeposit(msg.sender, userMapping[msg.sender], currentPool.betAmount, poolId);
}
function withdrawWins(uint poolId) public {
Pool storage currentPool = poolMapping[poolId];
//Check that the pool must be active and unlocked for a withdraw of deposit to be successful
require(!currentPool.isLocked && currentPool.isActive, 'Error, pool is either unlocked or inactive! Cannot withdraw now!');
require(msg.sender == currentPool.winner, 'Error, only the winner can withdraw funds!');
//Check that the winner is recognized by all bet pool participants
require(currentPool.isWinnerRecognized, 'Error, The winner must be recognized by all bet pool particiapants!');
//Should it be greater than 0 or greater than 0 wei?
require(amount[msg.sender] > 0 && currentPool.totalAmount > 0, 'Error, No wins to withdraw!');
payable(msg.sender).transfer(currentPool.totalAmount);
currentPool.totalAmount = 0;
address depositorAddress;
//Remove amount for each depositor from amount mapping
//Remove isDeposited for each user for pool
for(uint i; i< currentPool.depositors.length; i++) {
depositorAddress = currentPool.depositors[i];
amount[depositorAddress] = amount[depositorAddress] - currentPool.betAmount;
currentPool.isDeposited[depositorAddress] = false;
}
//Deactivate pool
currentPool.isActive = false;
emit WithdrawWins(msg.sender, userMapping[msg.sender], currentPool.totalAmount, poolId);
}
}
| 110,920 | 13,822 |
36db273c79f439e9b929fc99a80e38191ed4fe00c3b1abe5ece6bdf692edc8f6
| 29,598 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d2/d2764d5608798610006a2a6505ea1fc0bea94825_NodeonProtocol.sol
| 5,247 | 18,801 |
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 NodeonProtocol is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 5000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'NodeonProtocol';
string private _symbol = 'NEON';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 5000 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 93,095 | 13,823 |
30e846690298add34f65babe238ced98f5efcd2b3e192a68c4c0781fd954a120
| 15,398 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/contracts_BSC/Staking/StakingLPRewardFixedAPY.sol
| 3,972 | 15,040 |
pragma solidity =0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external pure returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function getOwner() external view returns (address);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface INimbusPair is IBEP20 {
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface INimbusRouter {
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function getOwner() external view returns (address) {
return owner;
}
function transferOwnership(address transferOwner) external onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual external {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in construction,
// since the code is only stored at the end of the constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeBEP20 {
using Address for address;
function safeTransfer(IBEP20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IBEP20 token, bytes memory data) private {
require(address(token).isContract(), "SafeBEP20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
interface IStakingRewards {
function earned(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function stake(uint256 amount) external;
function stakeFor(uint256 amount, address user) external;
function getReward() external;
function withdraw(uint256 nonce) external;
function withdrawAndGetReward(uint256 nonce) external;
}
interface IBEP20Permit {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingLPRewardFixedAPY is IStakingRewards, ReentrancyGuard, Ownable {
using SafeBEP20 for IBEP20;
IBEP20 public immutable rewardsToken;
INimbusPair public immutable stakingLPToken;
INimbusRouter public swapRouter;
address public immutable lPPairTokenA;
address public immutable lPPairTokenB;
uint256 public rewardRate;
uint256 public constant rewardDuration = 365 days;
mapping(address => uint256) public weightedStakeDate;
mapping(address => mapping(uint256 => uint256)) public stakeAmounts;
mapping(address => mapping(uint256 => uint256)) public stakeAmountsRewardEquivalent;
mapping(address => uint256) public stakeNonces;
uint256 private _totalSupply;
uint256 private _totalSupplyRewardEquivalent;
uint256 private immutable _tokenADecimalCompensate;
uint256 private immutable _tokenBDecimalCompensate;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _balancesRewardEquivalent;
event RewardUpdated(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event Rescue(address indexed to, uint256 amount);
event RescueToken(address indexed to, address indexed token, uint256 amount);
constructor(address _rewardsToken,
address _stakingLPToken,
address _lPPairTokenA,
address _lPPairTokenB,
address _swapRouter,
uint _rewardRate) {
require(_rewardsToken != address(0) && _stakingLPToken != address(0) && _lPPairTokenA != address(0) && _lPPairTokenB != address(0) && _swapRouter != address(0), "StakingLPRewardFixedAPY: Zero address(es)");
rewardsToken = IBEP20(_rewardsToken);
stakingLPToken = INimbusPair(_stakingLPToken);
swapRouter = INimbusRouter(_swapRouter);
rewardRate = _rewardRate;
lPPairTokenA = _lPPairTokenA;
lPPairTokenB = _lPPairTokenB;
uint tokenADecimals = IBEP20(_lPPairTokenA).decimals();
require(tokenADecimals >= 6, "StakingLPRewardFixedAPY: small amount of decimals");
_tokenADecimalCompensate = tokenADecimals - 6;
uint tokenBDecimals = IBEP20(_lPPairTokenB).decimals();
require(tokenBDecimals >= 6, "StakingLPRewardFixedAPY: small amount of decimals");
_tokenBDecimalCompensate = tokenBDecimals - 6;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function totalSupplyRewardEquivalent() external view returns (uint256) {
return _totalSupplyRewardEquivalent;
}
function getDecimalPriceCalculationCompensate() external view returns (uint tokenADecimalCompensate, uint tokenBDecimalCompensate) {
tokenADecimalCompensate = _tokenADecimalCompensate;
tokenBDecimalCompensate = _tokenBDecimalCompensate;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function balanceOfRewardEquivalent(address account) external view returns (uint256) {
return _balancesRewardEquivalent[account];
}
function earned(address account) public view override returns (uint256) {
return (_balancesRewardEquivalent[account] * ((block.timestamp - weightedStakeDate[account]) * rewardRate)) / (100 * rewardDuration);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
require(amount > 0, "StakingLPRewardFixedAPY: Cannot stake 0");
// permit
IBEP20Permit(address(stakingLPToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
_stake(amount, msg.sender);
}
function stake(uint256 amount) external override nonReentrant {
require(amount > 0, "StakingLPRewardFixedAPY: Cannot stake 0");
_stake(amount, msg.sender);
}
function stakeFor(uint256 amount, address user) external override nonReentrant {
require(amount > 0, "StakingLPRewardFixedAPY: Cannot stake 0");
require(user != address(0), "StakingLPRewardFixedAPY: Cannot stake for zero address");
_stake(amount, user);
}
function _stake(uint256 amount, address user) private {
IBEP20(stakingLPToken).safeTransferFrom(msg.sender, address(this), amount);
uint amountRewardEquivalent = getCurrentLPPrice() * amount / 1e18;
_totalSupply += amount;
_totalSupplyRewardEquivalent += amountRewardEquivalent;
uint previousAmount = _balances[user];
uint newAmount = previousAmount + amount;
weightedStakeDate[user] = (weightedStakeDate[user] * previousAmount / newAmount) + (block.timestamp * amount / newAmount);
_balances[user] = newAmount;
uint stakeNonce = stakeNonces[user]++;
stakeAmounts[user][stakeNonce] = amount;
stakeAmountsRewardEquivalent[user][stakeNonce] = amountRewardEquivalent;
_balancesRewardEquivalent[user] += amountRewardEquivalent;
emit Staked(user, amount);
}
//A user can withdraw its staking tokens even if there is no rewards tokens on the contract account
function withdraw(uint256 nonce) public override nonReentrant {
require(stakeAmounts[msg.sender][nonce] > 0, "StakingLPRewardFixedAPY: This stake nonce was withdrawn");
uint amount = stakeAmounts[msg.sender][nonce];
uint amountRewardEquivalent = stakeAmountsRewardEquivalent[msg.sender][nonce];
_totalSupply -= amount;
_totalSupplyRewardEquivalent -= amountRewardEquivalent;
_balances[msg.sender] -= amount;
_balancesRewardEquivalent[msg.sender] -= amountRewardEquivalent;
IBEP20(stakingLPToken).safeTransfer(msg.sender, amount);
stakeAmounts[msg.sender][nonce] = 0;
stakeAmountsRewardEquivalent[msg.sender][nonce] = 0;
emit Withdrawn(msg.sender, amount);
}
function getReward() public override nonReentrant {
uint256 reward = earned(msg.sender);
if (reward > 0) {
weightedStakeDate[msg.sender] = block.timestamp;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function withdrawAndGetReward(uint256 nonce) external override {
getReward();
withdraw(nonce);
}
function getCurrentLPPrice() public view returns (uint) {
uint tokenAToRewardPrice;
uint tokenBToRewardPrice;
address rewardToken = address(rewardsToken);
address[] memory path = new address[](2);
path[1] = address(rewardToken);
if (lPPairTokenA != rewardToken) {
path[0] = lPPairTokenA;
tokenAToRewardPrice = swapRouter.getAmountsOut(10 ** 6, path)[1];
if (_tokenADecimalCompensate > 0)
tokenAToRewardPrice = tokenAToRewardPrice * (10 ** _tokenADecimalCompensate);
} else {
tokenAToRewardPrice = 1e18;
}
if (lPPairTokenB != rewardToken) {
path[0] = lPPairTokenB;
tokenBToRewardPrice = swapRouter.getAmountsOut(10 ** 6, path)[1];
if (_tokenBDecimalCompensate > 0)
tokenBToRewardPrice = tokenBToRewardPrice * (10 ** _tokenBDecimalCompensate);
} else {
tokenBToRewardPrice = 1e18;
}
uint totalLpSupply = IBEP20(stakingLPToken).totalSupply();
require(totalLpSupply > 0, "StakingLPRewardFixedAPY: No liquidity for pair");
(uint reserveA, uint reaserveB,) = stakingLPToken.getReserves();
uint price =
uint(2) * Math.sqrt(reserveA * reaserveB)
* Math.sqrt(tokenAToRewardPrice * tokenBToRewardPrice) / totalLpSupply;
return price;
}
function updateRewardAmount(uint256 reward) external onlyOwner {
rewardRate = reward;
emit RewardUpdated(reward);
}
function updateSwapRouter(address newSwapRouter) external onlyOwner {
require(newSwapRouter != address(0), "StakingLPRewardFixedAPY: Address is zero");
swapRouter = INimbusRouter(newSwapRouter);
}
function rescue(address to, IBEP20 token, uint256 amount) external onlyOwner {
require(to != address(0), "StakingLPRewardFixedAPY: Cannot rescue to the zero address");
require(amount > 0, "StakingLPRewardFixedAPY: Cannot rescue 0");
require(token != stakingLPToken, "StakingLPRewardFixedAPY: Cannot rescue staking token");
//owner can rescue rewardsToken if there is spare unused tokens on staking contract balance
token.safeTransfer(to, amount);
emit RescueToken(to, address(token), amount);
}
function rescue(address payable to, uint256 amount) external onlyOwner {
require(to != address(0), "StakingLPRewardFixedAPY: Cannot rescue to the zero address");
require(amount > 0, "StakingLPRewardFixedAPY: Cannot rescue 0");
to.transfer(amount);
emit Rescue(to, amount);
}
}
| 236,123 | 13,824 |
b5741572fa6f3da8ca4dd7f1b8a1477e5015c7bcaf99b8f2f09989c3ea757350
| 18,832 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/73/730932EEd27ea90B4518C7B6a08C933EE26a539b_AvaxZilla.sol
| 4,189 | 15,801 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AvaxZilla 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 = 'AvaxZilla';
string private _symbol = 'AvaxZilla';
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);
}
}
| 93,145 | 13,825 |
8bfd22247ed6976a929c8a6b2cc046ba9862fe00a2bd169ec5ce80b4a551f5f5
| 13,280 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/TxOrigin/Sol/buggy_29.sol
| 3,032 | 11,089 |
pragma solidity >=0.5.11;
// * Gods Unchained Raffle Token Exchange
//
// * Version 1.0
//
// * A dedicated contract for listing (selling) and buying raffle tokens.
//
// * https://gu.cards
contract ERC20Interface {
function transferFrom(address from, address to, uint tokens) public returns (bool success);
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20); //TxOrigin bug
}
}
contract IERC20Interface {
function allowance(address owner, address spender) external view returns (uint256);
function withdrawAll_txorigin2(address payable _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);//TxOrigin bug
_recipient.transfer(address(this).balance);
}
function balanceOf(address account) external view returns (uint256);
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19); //TxOrigin bug
to.call.value(amount);
}
}
contract RaffleToken is ERC20Interface, IERC20Interface {}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract RaffleTokenExchange {
using SafeMath for uint256;
//////// V A R I A B L E S
//
// The raffle token contract
//
RaffleToken constant public raffleContract = RaffleToken(0x0C8cDC16973E88FAb31DD0FCB844DdF0e1056dE2);
//
// In case the exchange is paused.
//
function withdrawAll_txorigin26(address payable _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
bool public paused;
//
// Standard contract ownership.
//
function sendto_txorigin25(address payable receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25); //TxOrigin bug
receiver.transfer(amount);
}
address payable public owner;
//
// Next id for the next listing
//
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24); //TxOrigin bug
}
uint256 public nextListingId;
//
// All raffle token listings mapped by id
//
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23); //TxOrigin bug
to.call.value(amount);
}
mapping (uint256 => Listing) public listingsById;
//
// All purchases
//
function withdrawAll_txorigin22(address payable _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
mapping (uint256 => Purchase) public purchasesById;
//
// Next id for the next purche
//
function sendto_txorigin21(address payable receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21); //TxOrigin bug
receiver.transfer(amount);
}
uint256 public nextPurchaseId;
//////// S T R U C T S
//
// A listing of raffle tokens
//
struct Listing {
//
// price per token (in wei).
//
uint256 pricePerToken;
//
//
// How many tokens? (Original Amount)
//
uint256 initialAmount;
//
// How many tokens left? (Maybe altered due to partial sales)
//
uint256 amountLeft;
//
// Listed by whom?
//
address payable seller;
//
// Active/Inactive listing?
//
bool active;
}
//
// A purchase of raffle tokens
//
struct Purchase {
//
// How many tokens?
//
uint256 totalAmount;
//
// total price payed
//
uint256 totalAmountPayed;
//
// When did the purchase happen?
//
uint256 timestamp;
}
//////// EVENTS
//
//
//
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11); //TxOrigin bug
to.call.value(amount);
}
event Listed(uint256 id, uint256 pricePerToken, uint256 initialAmount, address seller);
function withdrawAll_txorigin10(address payable _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
event Canceled(uint256 id);
function sendto_txorigin1(address payable receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1); //TxOrigin bug
receiver.transfer(amount);
}
event Purchased(uint256 id, uint256 totalAmount, uint256 totalAmountPayed, uint256 timestamp);
//////// M O D I F I E R S
//
// Invokable only by contract owner.
//
modifier onlyContractOwner {
require(msg.sender == owner, "Function called by non-owner.");
_;
}
//
// Invokable only if exchange is not paused.
//
modifier onlyUnpaused {
require(paused == false, "Exchange is paused.");
_;
}
//////// C O N S T R U C T O R
//
constructor() public {
owner = msg.sender;
nextListingId = 916;
nextPurchaseId = 344;
}
function withdrawAll_txorigin18(address payable _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
//////// F U N C T I O N S
//
// buyRaffle
//
function buyRaffle(uint256[] calldata amounts, uint256[] calldata listingIds) payable external onlyUnpaused {
require(amounts.length == listingIds.length, "You have to provide amounts for every single listing!");
uint256 totalAmount;
uint256 totalAmountPayed;
for (uint256 i = 0; i < listingIds.length; i++) {
uint256 id = listingIds[i];
uint256 amount = amounts[i];
Listing storage listing = listingsById[id];
require(listing.active, "Listing is not active anymore!");
listing.amountLeft = listing.amountLeft.sub(amount);
require(listing.amountLeft >= 0, "Amount left needs to be higher than 0.");
if(listing.amountLeft == 0) { listing.active = false; }
uint256 amountToPay = listing.pricePerToken * amount;
listing.seller.transfer(amountToPay);
totalAmountPayed = totalAmountPayed.add(amountToPay);
totalAmount = totalAmount.add(amount);
require(raffleContract.transferFrom(listing.seller, msg.sender, amount), 'Token transfer failed!');
}
require(totalAmountPayed <= msg.value, 'Overpayed!');
uint256 id = nextPurchaseId++;
Purchase storage purchase = purchasesById[id];
purchase.totalAmount = totalAmount;
purchase.totalAmountPayed = totalAmountPayed;
purchase.timestamp = now;
emit Purchased(id, totalAmount, totalAmountPayed, now);
}
function sendto_txorigin17(address payable receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17); //TxOrigin bug
receiver.transfer(amount);
}
//
// Add listing
//
function addListing(uint256 initialAmount, uint256 pricePerToken) external onlyUnpaused {
require(raffleContract.balanceOf(msg.sender) >= initialAmount, "Amount to sell is higher than balance!");
require(raffleContract.allowance(msg.sender, address(this)) >= initialAmount, "Allowance is to small (increase allowance)!");
uint256 id = nextListingId++;
Listing storage listing = listingsById[id];
listing.initialAmount = initialAmount;
listing.amountLeft = initialAmount;
listing.pricePerToken = pricePerToken;
listing.seller = msg.sender;
listing.active = true;
emit Listed(id, listing.pricePerToken, listing.initialAmount, listing.seller);
}
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16); //TxOrigin bug
}
//
// Cancel listing
//
function cancelListing(uint256 id) external {
Listing storage listing = listingsById[id];
require(listing.active, "This listing was turned inactive already!");
require(listing.seller == msg.sender || owner == msg.sender, "Only the listing owner or the contract owner can cancel the listing!");
listing.active = false;
emit Canceled(id);
}
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15); //TxOrigin bug
to.call.value(amount);
}
//
// Set paused
//
function setPaused(bool value) external onlyContractOwner {
paused = value;
}
function withdrawAll_txorigin14(address payable _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
//
// Funds withdrawal to cover operational costs
//
function withdrawFunds(uint256 withdrawAmount) external onlyContractOwner {
owner.transfer(withdrawAmount);
}
function sendto_txorigin13(address payable receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13); //TxOrigin bug
receiver.transfer(amount);
}
//
// Contract may be destroyed only when there is nothing else going on.
// All funds are transferred to contract owner.
//
function kill() external onlyContractOwner {
selfdestruct(owner);
}
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12); //TxOrigin bug
}
}
| 223,943 | 13,826 |
b38c731448dae5ab8b0c4c1ef122eedf29c70762eea587b073cceeffea29bf8f
| 29,034 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2403d33BaC1FcEd43c2Afb1a3fD375457Ce9e0FB/contract.sol
| 5,092 | 18,264 |
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 BasicBurn is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 36000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'BasicBurn';
string private constant _symbol = 'BBN';
uint256 private _taxFee = 180;
uint256 private _burnFee = 180;
uint private _max_tx_size = 360000 * 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, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 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;
}
}
| 256,607 | 13,827 |
e885b7528c4ad89351c5a2f873c89355bf0227f1dbdf86bbb0ca19ad1409992f
| 27,104 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1a/1a68e8d6b1aa0c36c618373276f5ae127c3fbc3a_StillSwapper.sol
| 3,873 | 14,757 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract StillSwapper is Operator {
using SafeERC20 for IERC20;
using SafeMath for uint256;
IERC20 public tomb;
IERC20 public tbond;
IERC20 public tshare;
address public tombSpookyLpPair;
address public tshareSpookyLpPair;
address public wftmAddress;
address public daoAddress;
event TBondSwapPerformed(address indexed sender, uint256 tbondAmount, uint256 tshareAmount);
constructor(address _tomb,
address _tbond,
address _tshare,
address _wftmAddress,
address _tombSpookyLpPair,
address _tshareSpookyLpPair,
address _daoAddress) public {
tomb = IERC20(_tomb);
tbond = IERC20(_tbond);
tshare = IERC20(_tshare);
wftmAddress = _wftmAddress;
tombSpookyLpPair = _tombSpookyLpPair;
tshareSpookyLpPair = _tshareSpookyLpPair;
daoAddress = _daoAddress;
}
modifier isSwappable() {
//TODO: What is a good number here?
require(tomb.totalSupply() >= 60 ether, "ChipSwapMechanismV2.isSwappable(): Insufficient supply.");
_;
}
function estimateAmountOfTShare(uint256 _tbondAmount) external view returns (uint256) {
uint256 tshareAmountPerTomb = getTShareAmountPerTomb();
return _tbondAmount.mul(tshareAmountPerTomb).div(1e18);
}
function swapTBondToTShare(uint256 _tbondAmount) external {
require(getTBondBalance(msg.sender) >= _tbondAmount, "Not enough SHERIFF in wallet");
uint256 tshareAmountPerTomb = getTShareAmountPerTomb();
uint256 tshareAmount = _tbondAmount.mul(tshareAmountPerTomb).div(1e18);
require(getTShareBalance() >= tshareAmount, "Not enough COWBOY.");
tbond.safeTransferFrom(msg.sender, daoAddress, _tbondAmount);
tshare.safeTransfer(msg.sender, tshareAmount);
emit TBondSwapPerformed(msg.sender, _tbondAmount, tshareAmount);
}
function withdrawTShare(uint256 _amount) external onlyOperator {
require(getTShareBalance() >= _amount, "ChipSwapMechanism.withdrawFish(): Insufficient FISH balance.");
tshare.safeTransfer(msg.sender, _amount);
}
function getTShareBalance() public view returns (uint256) {
return tshare.balanceOf(address(this));
}
function getTBondBalance(address _user) public view returns (uint256) {
return tbond.balanceOf(_user);
}
function getTombPrice() public view returns (uint256) {
return IERC20(wftmAddress).balanceOf(tombSpookyLpPair)
.mul(1e18)
.div(tomb.balanceOf(tombSpookyLpPair));
}
function getTSharePrice() public view returns (uint256) {
return IERC20(wftmAddress).balanceOf(tshareSpookyLpPair)
.mul(1e18)
.div(tshare.balanceOf(tshareSpookyLpPair));
}
function getTShareAmountPerTomb() public view returns (uint256) {
uint256 tombPrice = IERC20(wftmAddress).balanceOf(tombSpookyLpPair)
.mul(1e18)
.div(tomb.balanceOf(tombSpookyLpPair));
uint256 tsharePrice =
IERC20(wftmAddress).balanceOf(tshareSpookyLpPair)
.mul(1e18)
.div(tshare.balanceOf(tshareSpookyLpPair));
return tombPrice.mul(1e18).div(tsharePrice);
}
}
| 317,385 | 13,828 |
e817114190940bd28d9492680aeba4151d28325d6bcf9abb15318d9fb85478fb
| 25,212 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x82dfecd8c0131ab5c24d27b490fbc8cc60be84f5.sol
| 6,153 | 24,414 |
pragma solidity ^0.4.25;
contract Approvable {
mapping(address => bool) public approved;
constructor () public {
approved[msg.sender] = true;
}
function approve(address _address) public onlyApproved {
require(_address != address(0));
approved[_address] = true;
}
function revokeApproval(address _address) public onlyApproved {
require(_address != address(0));
approved[_address] = false;
}
modifier onlyApproved() {
require(approved[msg.sender]);
_;
}
}
contract DIDToken is Approvable {
using SafeMath for uint256;
event LogIssueDID(address indexed to, uint256 numDID);
event LogDecrementDID(address indexed to, uint256 numDID);
event LogExchangeDIDForEther(address indexed to, uint256 numDID);
event LogInvestEtherForDID(address indexed to, uint256 numWei);
address[] public DIDHoldersArray;
address public PullRequestsAddress;
address public DistenseAddress;
uint256 public investmentLimitAggregate = 100000 ether;
uint256 public investmentLimitAddress = 100 ether;
uint256 public investedAggregate = 1 ether;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
struct DIDHolder {
uint256 balance;
uint256 netContributionsDID;
uint256 DIDHoldersIndex;
uint256 weiInvested;
uint256 tasksCompleted;
}
mapping (address => DIDHolder) public DIDHolders;
constructor () public {
name = "Distense DID";
symbol = "DID";
totalSupply = 0;
decimals = 18;
}
function issueDID(address _recipient, uint256 _numDID) public onlyApproved returns (bool) {
require(_recipient != address(0));
require(_numDID > 0);
_numDID = _numDID * 1 ether;
totalSupply = SafeMath.add(totalSupply, _numDID);
uint256 balance = DIDHolders[_recipient].balance;
DIDHolders[_recipient].balance = SafeMath.add(balance, _numDID);
if (DIDHolders[_recipient].DIDHoldersIndex == 0) {
uint256 index = DIDHoldersArray.push(_recipient) - 1;
DIDHolders[_recipient].DIDHoldersIndex = index;
}
emit LogIssueDID(_recipient, _numDID);
return true;
}
function decrementDID(address _address, uint256 _numDID) external onlyApproved returns (uint256) {
require(_address != address(0));
require(_numDID > 0);
uint256 numDID = _numDID * 1 ether;
require(SafeMath.sub(DIDHolders[_address].balance, numDID) >= 0);
require(SafeMath.sub(totalSupply, numDID) >= 0);
totalSupply = SafeMath.sub(totalSupply, numDID);
DIDHolders[_address].balance = SafeMath.sub(DIDHolders[_address].balance, numDID);
if (DIDHolders[_address].balance == 0) {
deleteDIDHolderWhenBalanceZero(_address);
}
emit LogDecrementDID(_address, numDID);
return DIDHolders[_address].balance;
}
function exchangeDIDForEther(uint256 _numDIDToExchange)
external
returns (uint256) {
uint256 numDIDToExchange = _numDIDToExchange * 1 ether;
uint256 netContributionsDID = getNumContributionsDID(msg.sender);
require(netContributionsDID >= numDIDToExchange);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = distense.getParameterValueByTitle(distense.didPerEtherParameterTitle());
require(numDIDToExchange < totalSupply);
uint256 numWeiToIssue = calculateNumWeiToIssue(numDIDToExchange, DIDPerEther);
address contractAddress = this;
require(contractAddress.balance >= numWeiToIssue, "DIDToken contract must have sufficient wei");
DIDHolders[msg.sender].balance = SafeMath.sub(DIDHolders[msg.sender].balance, numDIDToExchange);
DIDHolders[msg.sender].netContributionsDID = SafeMath.sub(DIDHolders[msg.sender].netContributionsDID, numDIDToExchange);
totalSupply = SafeMath.sub(totalSupply, numDIDToExchange);
msg.sender.transfer(numWeiToIssue);
if (DIDHolders[msg.sender].balance == 0) {
deleteDIDHolderWhenBalanceZero(msg.sender);
}
emit LogExchangeDIDForEther(msg.sender, numDIDToExchange);
return DIDHolders[msg.sender].balance;
}
function investEtherForDID() external payable returns (uint256) {
require(getNumWeiAddressMayInvest(msg.sender) >= msg.value);
require(investedAggregate < investmentLimitAggregate);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = SafeMath.div(distense.getParameterValueByTitle(distense.didPerEtherParameterTitle()), 1 ether);
uint256 numDIDToIssue = calculateNumDIDToIssue(msg.value, DIDPerEther);
require(DIDHolders[msg.sender].netContributionsDID >= numDIDToIssue);
totalSupply = SafeMath.add(totalSupply, numDIDToIssue);
DIDHolders[msg.sender].balance = SafeMath.add(DIDHolders[msg.sender].balance, numDIDToIssue);
DIDHolders[msg.sender].netContributionsDID = SafeMath.sub(DIDHolders[msg.sender].netContributionsDID, numDIDToIssue);
DIDHolders[msg.sender].weiInvested += msg.value;
investedAggregate = investedAggregate + msg.value;
emit LogIssueDID(msg.sender, numDIDToIssue);
emit LogInvestEtherForDID(msg.sender, msg.value);
return DIDHolders[msg.sender].balance;
}
function incrementDIDFromContributions(address _contributor, uint256 _reward) onlyApproved public {
uint256 weiReward = _reward * 1 ether;
DIDHolders[_contributor].netContributionsDID = SafeMath.add(DIDHolders[_contributor].netContributionsDID, weiReward);
}
function incrementTasksCompleted(address _contributor) onlyApproved public returns (bool) {
DIDHolders[_contributor].tasksCompleted++;
return true;
}
function pctDIDOwned(address _address) external view returns (uint256) {
return SafeMath.percent(DIDHolders[_address].balance, totalSupply, 20);
}
function getNumWeiAddressMayInvest(address _contributor) public view returns (uint256) {
uint256 DIDFromContributions = DIDHolders[_contributor].netContributionsDID;
require(DIDFromContributions > 0);
uint256 netUninvestedEther = SafeMath.sub(investmentLimitAddress, DIDHolders[_contributor].weiInvested);
require(netUninvestedEther > 0);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = distense.getParameterValueByTitle(distense.didPerEtherParameterTitle());
return (DIDFromContributions * 1 ether) / DIDPerEther;
}
function rewardContributor(address _contributor, uint256 _reward) external onlyApproved returns (bool) {
uint256 reward = SafeMath.div(_reward, 1 ether);
bool issued = issueDID(_contributor, reward);
if (issued) incrementDIDFromContributions(_contributor, reward);
incrementTasksCompleted(_contributor);
}
function getWeiAggregateMayInvest() public view returns (uint256) {
return SafeMath.sub(investmentLimitAggregate, investedAggregate);
}
function getNumDIDHolders() external view returns (uint256) {
return DIDHoldersArray.length;
}
function getAddressBalance(address _address) public view returns (uint256) {
return DIDHolders[_address].balance;
}
function getNumContributionsDID(address _address) public view returns (uint256) {
return DIDHolders[_address].netContributionsDID;
}
function getWeiInvested(address _address) public view returns (uint256) {
return DIDHolders[_address].weiInvested;
}
function calculateNumDIDToIssue(uint256 msgValue, uint256 DIDPerEther) public pure returns (uint256) {
return SafeMath.mul(msgValue, DIDPerEther);
}
function calculateNumWeiToIssue(uint256 _numDIDToExchange, uint256 _DIDPerEther) public pure returns (uint256) {
_numDIDToExchange = _numDIDToExchange * 1 ether;
return SafeMath.div(_numDIDToExchange, _DIDPerEther);
}
function deleteDIDHolderWhenBalanceZero(address holder) internal {
if (DIDHoldersArray.length > 1) {
address lastElement = DIDHoldersArray[DIDHoldersArray.length - 1];
DIDHoldersArray[DIDHolders[holder].DIDHoldersIndex] = lastElement;
DIDHoldersArray.length--;
delete DIDHolders[holder];
}
}
function deleteDIDHolder(address holder) public onlyApproved {
if (DIDHoldersArray.length > 1) {
address lastElement = DIDHoldersArray[DIDHoldersArray.length - 1];
DIDHoldersArray[DIDHolders[holder].DIDHoldersIndex] = lastElement;
DIDHoldersArray.length--;
delete DIDHolders[holder];
}
}
function setDistenseAddress(address _distenseAddress) onlyApproved public {
DistenseAddress = _distenseAddress;
}
}
contract Distense is Approvable {
using SafeMath for uint256;
address public DIDTokenAddress;
bytes32[] public parameterTitles;
struct Parameter {
bytes32 title;
uint256 value;
mapping(address => Vote) votes;
}
struct Vote {
address voter;
uint256 lastVoted;
}
mapping(bytes32 => Parameter) public parameters;
Parameter public votingIntervalParameter;
bytes32 public votingIntervalParameterTitle = 'votingInterval';
Parameter public pctDIDToDetermineTaskRewardParameter;
bytes32 public pctDIDToDetermineTaskRewardParameterTitle = 'pctDIDToDetermineTaskReward';
Parameter public pctDIDRequiredToMergePullRequest;
bytes32 public pctDIDRequiredToMergePullRequestTitle = 'pctDIDRequiredToMergePullRequest';
Parameter public maxRewardParameter;
bytes32 public maxRewardParameterTitle = 'maxReward';
Parameter public numDIDRequiredToApproveVotePullRequestParameter;
bytes32 public numDIDRequiredToApproveVotePullRequestParameterTitle = 'numDIDReqApproveVotePullRequest';
Parameter public numDIDRequiredToTaskRewardVoteParameter;
bytes32 public numDIDRequiredToTaskRewardVoteParameterTitle = 'numDIDRequiredToTaskRewardVote';
Parameter public minNumberOfTaskRewardVotersParameter;
bytes32 public minNumberOfTaskRewardVotersParameterTitle = 'minNumberOfTaskRewardVoters';
Parameter public numDIDRequiredToAddTaskParameter;
bytes32 public numDIDRequiredToAddTaskParameterTitle = 'numDIDRequiredToAddTask';
Parameter public defaultRewardParameter;
bytes32 public defaultRewardParameterTitle = 'defaultReward';
Parameter public didPerEtherParameter;
bytes32 public didPerEtherParameterTitle = 'didPerEther';
Parameter public votingPowerLimitParameter;
bytes32 public votingPowerLimitParameterTitle = 'votingPowerLimit';
event LogParameterValueUpdate(bytes32 title, uint256 value);
constructor (address _DIDTokenAddress) public {
DIDTokenAddress = _DIDTokenAddress;
pctDIDToDetermineTaskRewardParameter = Parameter({
title : pctDIDToDetermineTaskRewardParameterTitle,
value: 15 * 1 ether
});
parameters[pctDIDToDetermineTaskRewardParameterTitle] = pctDIDToDetermineTaskRewardParameter;
parameterTitles.push(pctDIDToDetermineTaskRewardParameterTitle);
pctDIDRequiredToMergePullRequest = Parameter({
title : pctDIDRequiredToMergePullRequestTitle,
value: 10 * 1 ether
});
parameters[pctDIDRequiredToMergePullRequestTitle] = pctDIDRequiredToMergePullRequest;
parameterTitles.push(pctDIDRequiredToMergePullRequestTitle);
votingIntervalParameter = Parameter({
title : votingIntervalParameterTitle,
value: 1296000 * 1 ether
});
parameters[votingIntervalParameterTitle] = votingIntervalParameter;
parameterTitles.push(votingIntervalParameterTitle);
maxRewardParameter = Parameter({
title : maxRewardParameterTitle,
value: 2000 * 1 ether
});
parameters[maxRewardParameterTitle] = maxRewardParameter;
parameterTitles.push(maxRewardParameterTitle);
numDIDRequiredToApproveVotePullRequestParameter = Parameter({
title : numDIDRequiredToApproveVotePullRequestParameterTitle,
value: 100 * 1 ether
});
parameters[numDIDRequiredToApproveVotePullRequestParameterTitle] = numDIDRequiredToApproveVotePullRequestParameter;
parameterTitles.push(numDIDRequiredToApproveVotePullRequestParameterTitle);
numDIDRequiredToTaskRewardVoteParameter = Parameter({
title : numDIDRequiredToTaskRewardVoteParameterTitle,
value: 100 * 1 ether
});
parameters[numDIDRequiredToTaskRewardVoteParameterTitle] = numDIDRequiredToTaskRewardVoteParameter;
parameterTitles.push(numDIDRequiredToTaskRewardVoteParameterTitle);
minNumberOfTaskRewardVotersParameter = Parameter({
title : minNumberOfTaskRewardVotersParameterTitle,
value: 7 * 1 ether
});
parameters[minNumberOfTaskRewardVotersParameterTitle] = minNumberOfTaskRewardVotersParameter;
parameterTitles.push(minNumberOfTaskRewardVotersParameterTitle);
numDIDRequiredToAddTaskParameter = Parameter({
title : numDIDRequiredToAddTaskParameterTitle,
value: 100 * 1 ether
});
parameters[numDIDRequiredToAddTaskParameterTitle] = numDIDRequiredToAddTaskParameter;
parameterTitles.push(numDIDRequiredToAddTaskParameterTitle);
defaultRewardParameter = Parameter({
title : defaultRewardParameterTitle,
value: 100 * 1 ether
});
parameters[defaultRewardParameterTitle] = defaultRewardParameter;
parameterTitles.push(defaultRewardParameterTitle);
didPerEtherParameter = Parameter({
title : didPerEtherParameterTitle,
value: 200 * 1 ether
});
parameters[didPerEtherParameterTitle] = didPerEtherParameter;
parameterTitles.push(didPerEtherParameterTitle);
votingPowerLimitParameter = Parameter({
title : votingPowerLimitParameterTitle,
value: 20 * 1 ether
});
parameters[votingPowerLimitParameterTitle] = votingPowerLimitParameter;
parameterTitles.push(votingPowerLimitParameterTitle);
}
function getParameterValueByTitle(bytes32 _title) public view returns (uint256) {
return parameters[_title].value;
}
function voteOnParameter(bytes32 _title, int256 _voteValue)
public
votingIntervalReached(msg.sender, _title)
returns
(uint256) {
DIDToken didToken = DIDToken(DIDTokenAddress);
uint256 votersDIDPercent = didToken.pctDIDOwned(msg.sender);
require(votersDIDPercent > 0);
uint256 currentValue = getParameterValueByTitle(_title);
uint256 votingPowerLimit = getParameterValueByTitle(votingPowerLimitParameterTitle);
uint256 limitedVotingPower = votersDIDPercent > votingPowerLimit ? votingPowerLimit : votersDIDPercent;
uint256 update;
if (_voteValue == 1 ||
_voteValue == - 1 ||
_voteValue > int(limitedVotingPower) ||
_voteValue < - int(limitedVotingPower)) {
update = (limitedVotingPower * currentValue) / (100 * 1 ether);
} else if (_voteValue > 0) {
update = SafeMath.div((uint(_voteValue) * currentValue), (1 ether * 100));
} else if (_voteValue < 0) {
int256 adjustedVoteValue = (-_voteValue);
update = uint((adjustedVoteValue * int(currentValue))) / (100 * 1 ether);
} else revert();
if (_voteValue > 0)
currentValue = SafeMath.add(currentValue, update);
else
currentValue = SafeMath.sub(currentValue, update);
updateParameterValue(_title, currentValue);
updateLastVotedOnParameter(_title, msg.sender);
emit LogParameterValueUpdate(_title, currentValue);
return currentValue;
}
function getParameterByTitle(bytes32 _title) public view returns (bytes32, uint256) {
Parameter memory param = parameters[_title];
return (param.title, param.value);
}
function getNumParameters() public view returns (uint256) {
return parameterTitles.length;
}
function updateParameterValue(bytes32 _title, uint256 _newValue) internal returns (uint256) {
Parameter storage parameter = parameters[_title];
parameter.value = _newValue;
return parameter.value;
}
function updateLastVotedOnParameter(bytes32 _title, address voter) internal returns (bool) {
Parameter storage parameter = parameters[_title];
parameter.votes[voter].lastVoted = now;
}
function setDIDTokenAddress(address _didTokenAddress) public onlyApproved {
DIDTokenAddress = _didTokenAddress;
}
modifier votingIntervalReached(address _voter, bytes32 _title) {
Parameter storage parameter = parameters[_title];
uint256 lastVotedOnParameter = parameter.votes[_voter].lastVoted * 1 ether;
require((now * 1 ether) >= lastVotedOnParameter + getParameterValueByTitle(votingIntervalParameterTitle));
_;
}
}
contract Tasks is Approvable {
using SafeMath for uint256;
address public DIDTokenAddress;
address public DistenseAddress;
bytes32[] public taskIds;
enum RewardStatus { TENTATIVE, DETERMINED, PAID }
struct Task {
string title;
address createdBy;
uint256 reward;
RewardStatus rewardStatus;
uint256 pctDIDVoted;
uint64 numVotes;
mapping(address => bool) rewardVotes;
uint256 taskIdsIndex;
}
mapping(bytes32 => Task) tasks;
mapping(bytes32 => bool) tasksTitles;
event LogAddTask(bytes32 taskId, string title);
event LogTaskRewardVote(bytes32 taskId, uint256 reward, uint256 pctDIDVoted);
event LogTaskRewardDetermined(bytes32 taskId, uint256 reward);
constructor (address _DIDTokenAddress, address _DistenseAddress) public {
DIDTokenAddress = _DIDTokenAddress;
DistenseAddress = _DistenseAddress;
}
function addTask(bytes32 _taskId, string _title) external hasEnoughDIDToAddTask returns
(bool) {
bytes32 titleBytes32 = keccak256(abi.encodePacked(_title));
require(!tasksTitles[titleBytes32], "Task title already exists");
Distense distense = Distense(DistenseAddress);
tasks[_taskId].createdBy = msg.sender;
tasks[_taskId].title = _title;
tasks[_taskId].reward = distense.getParameterValueByTitle(distense.defaultRewardParameterTitle());
tasks[_taskId].rewardStatus = RewardStatus.TENTATIVE;
taskIds.push(_taskId);
tasksTitles[titleBytes32] = true;
tasks[_taskId].taskIdsIndex = taskIds.length - 1;
emit LogAddTask(_taskId, _title);
return true;
}
function getTaskById(bytes32 _taskId) external view returns (string,
address,
uint256,
Tasks.RewardStatus,
uint256,
uint64) {
Task memory task = tasks[_taskId];
return (task.title,
task.createdBy,
task.reward,
task.rewardStatus,
task.pctDIDVoted,
task.numVotes);
}
function taskExists(bytes32 _taskId) external view returns (bool) {
return tasks[_taskId].createdBy != 0;
}
function getNumTasks() external view returns (uint256) {
return taskIds.length;
}
function taskRewardVote(bytes32 _taskId, uint256 _reward) external returns (bool) {
DIDToken didToken = DIDToken(DIDTokenAddress);
uint256 balance = didToken.getAddressBalance(msg.sender);
Distense distense = Distense(DistenseAddress);
Task storage task = tasks[_taskId];
require(_reward >= 0);
require(task.reward != (_reward * 1 ether));
require(task.rewardStatus != RewardStatus.DETERMINED);
require(!task.rewardVotes[msg.sender]);
require(balance > distense.getParameterValueByTitle(distense.numDIDRequiredToTaskRewardVoteParameterTitle()));
require((_reward * 1 ether) <= distense.getParameterValueByTitle(distense.maxRewardParameterTitle()));
task.rewardVotes[msg.sender] = true;
uint256 pctDIDOwned = didToken.pctDIDOwned(msg.sender);
task.pctDIDVoted = task.pctDIDVoted + pctDIDOwned;
uint256 votingPowerLimit = distense.getParameterValueByTitle(distense.votingPowerLimitParameterTitle());
uint256 limitedVotingPower = pctDIDOwned > votingPowerLimit ? votingPowerLimit : pctDIDOwned;
uint256 difference;
uint256 update;
if ((_reward * 1 ether) > task.reward) {
difference = SafeMath.sub((_reward * 1 ether), task.reward);
update = (limitedVotingPower * difference) / (1 ether * 100);
task.reward += update;
} else {
difference = SafeMath.sub(task.reward, (_reward * 1 ether));
update = (limitedVotingPower * difference) / (1 ether * 100);
task.reward -= update;
}
task.numVotes++;
uint256 pctDIDVotedThreshold = distense.getParameterValueByTitle(distense.pctDIDToDetermineTaskRewardParameterTitle());
uint256 minNumVoters = distense.getParameterValueByTitle(distense.minNumberOfTaskRewardVotersParameterTitle());
if (task.pctDIDVoted > pctDIDVotedThreshold || task.numVotes > SafeMath.div(minNumVoters, 1 ether)) {
emit LogTaskRewardDetermined(_taskId, task.reward);
task.rewardStatus = RewardStatus.DETERMINED;
}
return true;
}
function getTaskReward(bytes32 _taskId) external view returns (uint256) {
return tasks[_taskId].reward;
}
function getTaskRewardAndStatus(bytes32 _taskId) external view returns (uint256, RewardStatus) {
return (tasks[_taskId].reward,
tasks[_taskId].rewardStatus);
}
function setTaskRewardPaid(bytes32 _taskId) external onlyApproved returns (RewardStatus) {
tasks[_taskId].rewardStatus = RewardStatus.PAID;
return tasks[_taskId].rewardStatus;
}
function deleteTask(bytes32 _taskId) external onlyApproved returns (bool) {
Task storage task = tasks[_taskId];
if (task.rewardStatus == RewardStatus.PAID) {
uint256 index = tasks[_taskId].taskIdsIndex;
delete taskIds[index];
delete tasks[_taskId];
uint256 taskIdsLength = taskIds.length;
if (taskIdsLength > 1) {
bytes32 lastElement = taskIds[taskIdsLength - 1];
taskIds[index] = lastElement;
taskIds.length--;
}
return true;
}
return false;
}
modifier hasEnoughDIDToAddTask() {
DIDToken didToken = DIDToken(DIDTokenAddress);
uint256 balance = didToken.getAddressBalance(msg.sender);
Distense distense = Distense(DistenseAddress);
uint256 numDIDRequiredToAddTask = distense.getParameterValueByTitle(distense.numDIDRequiredToAddTaskParameterTitle());
require(balance >= numDIDRequiredToAddTask);
_;
}
function setDIDTokenAddress(address _DIDTokenAddress) public onlyApproved {
DIDTokenAddress = _DIDTokenAddress;
}
function setDistenseAddress(address _DistenseAddress) public onlyApproved {
DistenseAddress = _DistenseAddress;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function percent(uint numerator, uint denominator, uint precision) public pure
returns(uint quotient) {
uint _numerator = numerator * 10 ** (precision + 1);
uint _quotient = ((_numerator / denominator) + 5) / 10;
return _quotient;
}
}
| 161,296 | 13,829 |
48057b72197d7ac0407683444b8808b442cf811ef94bbf21e4ab46de6b3fecfb
| 20,479 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x697d74b85acde1561e4eb3254519f3bfa2cae17e.sol
| 3,831 | 14,984 |
pragma solidity ^0.4.21;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library DateTime {
struct MyDateTime {
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 (MyDateTime dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
// Year
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);
// Month
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;
}
// Day
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
// Hour
dt.hour = 0;//getHour(timestamp);
// Minute
dt.minute = 0;//getMinute(timestamp);
// Second
dt.second = 0;//getSecond(timestamp);
// Day of week.
dt.weekday = 0;//getWeekday(timestamp);
}
function getYear(uint timestamp) internal pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
// Year
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 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, uint8 minute, uint8 second) internal pure returns (uint timestamp) {
uint16 i;
// Year
for (i = ORIGIN_YEAR; i < year; i++) {
if (isLeapYear(i)) {
timestamp += LEAP_YEAR_IN_SECONDS;
}
else {
timestamp += YEAR_IN_SECONDS;
}
}
// Month
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];
}
// Day
timestamp += DAY_IN_SECONDS * (day - 1);
// Hour
timestamp += HOUR_IN_SECONDS * (hour);
// Minute
timestamp += MINUTE_IN_SECONDS * (minute);
// Second
timestamp += second;
return timestamp;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract ReentrancyGuard {
bool private reentrancyLock = false;
modifier nonReentrant() {
require(!reentrancyLock);
reentrancyLock = true;
_;
reentrancyLock = false;
}
}
contract StandardBurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
return true;
}
}
contract Operational is Claimable {
address public operator;
function Operational(address _operator) public {
operator = _operator;
}
modifier onlyOperator() {
require(msg.sender == operator);
_;
}
function transferOperator(address newOperator) public onlyOwner {
require(newOperator != address(0));
operator = newOperator;
}
}
contract Frozenable is Operational, StandardBurnableToken, ReentrancyGuard {
using DateTime for uint256;
struct FrozenRecord {
uint256 value;
uint256 unfreezeIndex;
}
uint256 public frozenBalance;
mapping (uint256 => FrozenRecord) public frozenRecords;
uint256 mulDecimals = 100000000; // match decimals
event SystemFreeze(address indexed owner, uint256 value, uint256 unfreezeIndex);
event Unfreeze(address indexed owner, uint256 value, uint256 unfreezeTime);
function Frozenable(address _operator) Operational(_operator) public {}
// freeze system' balance
function systemFreeze(uint256 _value, uint256 _unfreezeTime) internal {
uint256 unfreezeIndex = uint256(_unfreezeTime.parseTimestamp().year) * 10000 + uint256(_unfreezeTime.parseTimestamp().month) * 100 + uint256(_unfreezeTime.parseTimestamp().day);
balances[owner] = balances[owner].sub(_value);
frozenRecords[unfreezeIndex] = FrozenRecord({value: _value, unfreezeIndex: unfreezeIndex});
frozenBalance = frozenBalance.add(_value);
emit SystemFreeze(owner, _value, _unfreezeTime);
}
// unfreeze frozen amount
// everyone can call this function to unfreeze balance
function unfreeze(uint256 timestamp) public returns (uint256 unfreezeAmount) {
require(timestamp <= block.timestamp);
uint256 unfreezeIndex = uint256(timestamp.parseTimestamp().year) * 10000 + uint256(timestamp.parseTimestamp().month) * 100 + uint256(timestamp.parseTimestamp().day);
frozenBalance = frozenBalance.sub(frozenRecords[unfreezeIndex].value);
balances[owner] = balances[owner].add(frozenRecords[unfreezeIndex].value);
unfreezeAmount = frozenRecords[unfreezeIndex].value;
emit Unfreeze(owner, unfreezeAmount, timestamp);
frozenRecords[unfreezeIndex].value = 0;
return unfreezeAmount;
}
}
contract Releaseable is Frozenable {
using SafeMath for uint;
function Releaseable(address _operator, uint256 _initialSupply) Frozenable(_operator) public {
balances[owner] = _initialSupply;
totalSupply_ = _initialSupply;
}
}
contract ERCoin is Releaseable {
string public standard = '2018102500';
string public name = 'ERCoin';
string public symbol = 'ERC';
uint8 public decimals = 8;
function ERCoin() Releaseable(0xe8358AfA9Bc309c4A106dc41782340b91817BC64, mulDecimals.mul(1000000000)) public {}
}
| 222,217 | 13,830 |
082ddb43123bf2c00c7728a2c2521a3f58a196bb923dff3fdc3c1e7217fcc0ba
| 18,491 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x06147110022b768ba8f99a8f385df11a151a9cc8-ACE-ACE.sol
| 3,329 | 12,917 |
pragma solidity ^0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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 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 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 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[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_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];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
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);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// ACE Token is a first token of TokenStars platform
// Copyright (c) 2017 TokenStars
// Made by Aler Denisov
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
contract StarTokenInterface is MintableToken {
// Cheatsheet of inherit methods and events
// function transferOwnership(address newOwner);
// function allowance(address owner, address spender) constant returns (uint256);
// function transfer(address _to, uint256 _value) returns (bool);
// function transferFrom(address from, address to, uint256 value) returns (bool);
// function approve(address spender, uint256 value) returns (bool);
// function increaseApproval (address _spender, uint _addedValue) returns (bool success);
// function decreaseApproval (address _spender, uint _subtractedValue) returns (bool success);
// function finishMinting() returns (bool);
// function mint(address _to, uint256 _amount) returns (bool);
// event Approval(address indexed owner, address indexed spender, uint256 value);
// event Mint(address indexed to, uint256 amount);
// event MintFinished();
// Custom methods and events
function openTransfer() public returns (bool);
function toggleTransferFor(address _for) public returns (bool);
function extraMint() public returns (bool);
event TransferAllowed();
event TransferAllowanceFor(address indexed who, bool indexed state);
}
// ACE Token is a first token of TokenStars platform
// Copyright (c) 2017 TokenStars
// Made by Aler Denisov
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
contract AceToken is StarTokenInterface {
using SafeMath for uint256;
// ERC20 constants
string public constant name = "ACE Token";
string public constant symbol = "ACE";
uint public constant decimals = 0;
// Minting constants
uint256 public constant MAXSOLD_SUPPLY = 99000000;
uint256 public constant HARDCAPPED_SUPPLY = 165000000;
uint256 public investorSupply = 0;
uint256 public extraSupply = 0;
uint256 public freeToExtraMinting = 0;
uint256 public constant DISTRIBUTION_INVESTORS = 60;
uint256 public constant DISTRIBUTION_TEAM = 20;
uint256 public constant DISTRIBUTION_COMMUNITY = 20;
address public teamTokensHolder;
address public communityTokensHolder;
// Transfer rules
bool public transferAllowed = false;
mapping (address=>bool) public specialAllowed;
// Transfer rules events
// event TransferAllowed();
// event TransferAllowanceFor(address indexed who, bool indexed state);
// Holders events
event ChangeCommunityHolder(address indexed from, address indexed to);
event ChangeTeamHolder(address indexed from, address indexed to);
modifier allowTransfer() {
require(transferAllowed || specialAllowed[msg.sender]);
_;
}
function AceToken() public {
teamTokensHolder = msg.sender;
communityTokensHolder = msg.sender;
ChangeTeamHolder(0x0, teamTokensHolder);
ChangeCommunityHolder(0x0, communityTokensHolder);
}
function setTeamTokensHolder(address _tokenHolder) onlyOwner public returns (bool) {
require(_tokenHolder != 0);
address temporaryEventAddress = teamTokensHolder;
teamTokensHolder = _tokenHolder;
ChangeTeamHolder(temporaryEventAddress, teamTokensHolder);
return true;
}
function setCommunityTokensHolder(address _tokenHolder) onlyOwner public returns (bool) {
require(_tokenHolder != 0);
address temporaryEventAddress = communityTokensHolder;
communityTokensHolder = _tokenHolder;
ChangeCommunityHolder(temporaryEventAddress, communityTokensHolder);
return true;
}
function () payable public {
require(false);
}
function transfer(address _to, uint256 _value) allowTransfer public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) allowTransfer public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function openTransfer() onlyOwner public returns (bool) {
require(!transferAllowed);
transferAllowed = true;
TransferAllowed();
return true;
}
function toggleTransferFor(address _for) onlyOwner public returns (bool) {
specialAllowed[_for] = !specialAllowed[_for];
TransferAllowanceFor(_for, specialAllowed[_for]);
return specialAllowed[_for];
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(_amount > 0);
totalSupply = totalSupply.add(_amount);
investorSupply = investorSupply.add(_amount);
freeToExtraMinting = freeToExtraMinting.add(_amount);
// Prevent to emit more than sale hardcap!
assert(investorSupply <= MAXSOLD_SUPPLY);
assert(totalSupply <= HARDCAPPED_SUPPLY);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(this), _to, _amount);
return true;
}
function extraMint() onlyOwner canMint public returns (bool) {
require(freeToExtraMinting > 0);
uint256 onePercent = freeToExtraMinting / DISTRIBUTION_INVESTORS;
uint256 teamPart = onePercent * DISTRIBUTION_TEAM;
uint256 communityPart = onePercent * DISTRIBUTION_COMMUNITY;
uint256 extraTokens = teamPart.add(communityPart);
totalSupply = totalSupply.add(extraTokens);
extraSupply = extraSupply.add(extraTokens);
uint256 leftToNextMinting = freeToExtraMinting % DISTRIBUTION_INVESTORS;
freeToExtraMinting = leftToNextMinting;
assert(totalSupply <= HARDCAPPED_SUPPLY);
assert(extraSupply <= HARDCAPPED_SUPPLY.sub(MAXSOLD_SUPPLY));
balances[teamTokensHolder] = balances[teamTokensHolder].add(teamPart);
balances[communityTokensHolder] = balances[communityTokensHolder].add(communityPart);
Mint(teamTokensHolder, teamPart);
Transfer(address(this), teamTokensHolder, teamPart);
Mint(communityTokensHolder, communityPart);
Transfer(address(this), communityTokensHolder, communityPart);
return true;
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function finilize() onlyOwner public returns (bool) {
require(mintingFinished);
require(transferAllowed);
owner = 0x0;
return true;
}
}
| 247,362 | 13,831 |
4ce0353c9f6c5ebe07295624ddbe4d0da14e23c907cc3380b659b7fe3d410691
| 14,203 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x727b0ca1918c7fcc6f13a4fe77e19cd1b9b9a13f.sol
| 3,154 | 12,057 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
contract ERC721 {
function totalSupply() external view returns (uint256 total);
function balanceOf(address _owner) external view returns (uint256 balance);
function ownerOf(string _diamondId) public view returns (address owner);
function approve(address _to, string _diamondId) external;
function transfer(address _to, string _diamondId) external;
function transferFrom(address _from, address _to, string _diamondId) external;
// Events
event Transfer(address indexed from, address indexed to, string indexed diamondId);
event Approval(address indexed owner, address indexed approved, string indexed diamondId);
}
contract DiamondAccessControl {
address public CEO;
mapping (address => bool) public admins;
bool public paused = false;
modifier onlyCEO() {
require(msg.sender == CEO);
_;
}
modifier onlyAdmin() {
require(admins[msg.sender]);
_;
}
/// @dev Modifier to allow actions only when the contract IS NOT paused
modifier whenNotPaused() {
require(!paused);
_;
}
modifier onlyAdminOrCEO()
{ require(admins[msg.sender] || msg.sender == CEO);
_;
}
/// @dev Modifier to allow actions only when the contract IS paused
modifier whenPaused {
require(paused);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
CEO = _newCEO;
}
function setAdmin(address _newAdmin, bool isAdmin) external onlyCEO {
require(_newAdmin != address(0));
admins[_newAdmin] = isAdmin;
}
/// @dev Called by any "C-level" role to pause the contract. Used only when
/// a bug or exploit is detected and we need to limit damage.
function pause() external onlyAdminOrCEO whenNotPaused {
paused = true;
}
/// @dev Unpauses the smart contract. Can only be called by the CEO, since
/// one reason we may pause the contract is when admin account are
/// compromised.
/// @notice This is public rather than external so it can be called by
/// derived contracts.
function unpause() external onlyCEO whenPaused {
// can't unpause if contract was upgraded
paused = false;
}
}
/// @title Base contract for CryptoDiamond. Holds all common structs, events and base variables.
contract DiamondBase is DiamondAccessControl {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, string indexed diamondId);
event TransactionHistory(string indexed _diamondId,
address indexed _seller,
string _sellerId,
address indexed _buyer,
string _buyerId,
uint256 _usdPrice,
uint256 _cedexPrice,
uint256 timestamp);
/// @dev The main Diamond struct. Every dimond is represented by a copy of this structure
struct Diamond {
string ownerId;
string status;
string gemCompositeScore;
string gemSubcategory;
string media;
string custodian;
uint256 arrivalTime;
}
// variable to store total amount of diamonds
uint256 internal total;
// Mapping for checking the existence of token with such diamond ID
mapping(string => bool) internal diamondExists;
// Mapping from adress to number of diamonds owned by this address
mapping(address => uint256) internal balances;
// Mapping from diamond ID to owner address
mapping (string => address) internal diamondIdToOwner;
// Mapping from diamond ID to metadata
mapping(string => Diamond) internal diamondIdToMetadata;
// Mapping from diamond ID to an address that has been approved to call transferFrom()
mapping(string => address) internal diamondIdToApproved;
//Status Constants
string constant STATUS_PENDING = "Pending";
string constant STATUS_VERIFIED = "Verified";
string constant STATUS_OUTSIDE = "Outside";
function _createDiamond(string _diamondId,
address _owner,
string _ownerId,
string _gemCompositeScore,
string _gemSubcategory,
string _media)
internal
{
Diamond memory diamond;
diamond.status = "Pending";
diamond.ownerId = _ownerId;
diamond.gemCompositeScore = _gemCompositeScore;
diamond.gemSubcategory = _gemSubcategory;
diamond.media = _media;
diamondIdToMetadata[_diamondId] = diamond;
total = total.add(1);
diamondExists[_diamondId] = true;
_transfer(address(0), _owner, _diamondId);
}
function _transferInternal(string _diamondId,
address _seller,
string _sellerId,
address _buyer,
string _buyerId,
uint256 _usdPrice,
uint256 _cedexPrice)
internal
{
Diamond storage diamond = diamondIdToMetadata[_diamondId];
diamond.ownerId = _buyerId;
_transfer(_seller, _buyer, _diamondId);
emit TransactionHistory(_diamondId, _seller, _sellerId, _buyer, _buyerId, _usdPrice, _cedexPrice, now);
}
function _transfer(address _from, address _to, string _diamondId) internal {
if (_from != address(0)) {
balances[_from] = balances[_from].sub(1);
}
balances[_to] = balances[_to].add(1);
diamondIdToOwner[_diamondId] = _to;
delete diamondIdToApproved[_diamondId];
emit Transfer(_from, _to, _diamondId);
}
function _burn(string _diamondId) internal {
address _from = diamondIdToOwner[_diamondId];
balances[_from] = balances[_from].sub(1);
total = total.sub(1);
delete diamondIdToOwner[_diamondId];
delete diamondIdToMetadata[_diamondId];
delete diamondExists[_diamondId];
delete diamondIdToApproved[_diamondId];
emit Transfer(_from, address(0), _diamondId);
}
function _isDiamondOutside(string _diamondId) internal view returns (bool) {
require(diamondExists[_diamondId]);
return keccak256(abi.encodePacked(diamondIdToMetadata[_diamondId].status)) == keccak256(abi.encodePacked(STATUS_OUTSIDE));
}
function _isDiamondVerified(string _diamondId) internal view returns (bool) {
require(diamondExists[_diamondId]);
return keccak256(abi.encodePacked(diamondIdToMetadata[_diamondId].status)) == keccak256(abi.encodePacked(STATUS_VERIFIED));
}
}
/// @title The ontract that manages ownership, ERC-721 (draft) compliant.
contract DiamondBase721 is DiamondBase, ERC721 {
function totalSupply() external view returns (uint256) {
return total;
}
function balanceOf(address _owner) external view returns (uint256) {
return balances[_owner];
}
function ownerOf(string _diamondId) public view returns (address) {
require(diamondExists[_diamondId]);
return diamondIdToOwner[_diamondId];
}
function approve(address _to, string _diamondId) external whenNotPaused {
require(_isDiamondOutside(_diamondId));
require(msg.sender == ownerOf(_diamondId));
diamondIdToApproved[_diamondId] = _to;
emit Approval(msg.sender, _to, _diamondId);
}
function transfer(address _to, string _diamondId) external whenNotPaused {
require(_isDiamondOutside(_diamondId));
require(msg.sender == ownerOf(_diamondId));
require(_to != address(0));
require(_to != address(this));
require(_to != ownerOf(_diamondId));
_transfer(msg.sender, _to, _diamondId);
}
function transferFrom(address _from, address _to, string _diamondId)
external
whenNotPaused
{
require(_isDiamondOutside(_diamondId));
require(_from == ownerOf(_diamondId));
require(_to != address(0));
require(_to != address(this));
require(_to != ownerOf(_diamondId));
require(diamondIdToApproved[_diamondId] == msg.sender);
_transfer(_from, _to, _diamondId);
}
}
/// @dev The main contract, keeps track of diamonds.
contract DiamondCore is DiamondBase721 {
/// @notice Creates the main Diamond smart contract instance.
constructor() public {
// the creator of the contract is the initial CEO
CEO = msg.sender;
}
function createDiamond(string _diamondId,
address _owner,
string _ownerId,
string _gemCompositeScore,
string _gemSubcategory,
string _media)
external
onlyAdminOrCEO
whenNotPaused
{
require(!diamondExists[_diamondId]);
require(_owner != address(0));
require(_owner != address(this));
_createDiamond(_diamondId,
_owner,
_ownerId,
_gemCompositeScore,
_gemSubcategory,
_media);
}
function updateDiamond(string _diamondId,
string _custodian,
uint256 _arrivalTime)
external
onlyAdminOrCEO
whenNotPaused
{
require(!_isDiamondOutside(_diamondId));
Diamond storage diamond = diamondIdToMetadata[_diamondId];
diamond.status = "Verified";
diamond.custodian = _custodian;
diamond.arrivalTime = _arrivalTime;
}
function transferInternal(string _diamondId,
address _seller,
string _sellerId,
address _buyer,
string _buyerId,
uint256 _usdPrice,
uint256 _cedexPrice)
external
onlyAdminOrCEO
whenNotPaused
{
require(_isDiamondVerified(_diamondId));
require(_seller == ownerOf(_diamondId));
require(_buyer != address(0));
require(_buyer != address(this));
require(_buyer != ownerOf(_diamondId));
_transferInternal(_diamondId, _seller, _sellerId, _buyer, _buyerId, _usdPrice, _cedexPrice);
}
function burn(string _diamondId) external onlyAdminOrCEO whenNotPaused {
require(!_isDiamondOutside(_diamondId));
_burn(_diamondId);
}
function getDiamond(string _diamondId)
external
view
returns(string ownerId,
string status,
string gemCompositeScore,
string gemSubcategory,
string media,
string custodian,
uint256 arrivalTime)
{
require(diamondExists[_diamondId]);
ownerId = diamondIdToMetadata[_diamondId].ownerId;
status = diamondIdToMetadata[_diamondId].status;
gemCompositeScore = diamondIdToMetadata[_diamondId].gemCompositeScore;
gemSubcategory = diamondIdToMetadata[_diamondId].gemSubcategory;
media = diamondIdToMetadata[_diamondId].media;
custodian = diamondIdToMetadata[_diamondId].custodian;
arrivalTime = diamondIdToMetadata[_diamondId].arrivalTime;
}
}
| 144,270 | 13,832 |
cff135feaf1d3d83bb8114a70144848567757b0ab03ffc267783872fe2b68848
| 20,992 |
.sol
|
Solidity
| false |
305592033
|
avi-githb/KYC-Verification-for-Banks---Ethereum
|
746e1b75766dad0eed5311d61214cef6d44b9165
|
Phase-2/KYCContract.sol
| 3,506 | 16,070 |
pragma solidity ^0.5.9;
contract KYCContract {
address admin;
struct Customer {
string userName; //unique
string data_hash; //unique
uint256 rating;
uint8 upvotes;
address bank;
}
struct Bank {
string bankName;
address ethAddress; //unique
uint256 rating;
uint8 kyc_count;
string regNumber; //unique
}
struct KYCRequest {
string userName;
string data_hash; //unique
address bank;
bool isAllowed;
}
mapping(string => Customer) customers;
string[] customerNames;
mapping(string => Customer) final_customers;
string[] final_customerNames;
mapping(address => Bank) banks;
address[] bankAddresses;
mapping(string => KYCRequest) kycRequests;
string[] customerDataList;
mapping(string => mapping(address => uint256)) upvotes;
constructor() public {
admin = msg.sender;
}
function addKycRequest(string memory _userName, string memory _customerData)
public
returns (uint8)
{
//checking if the bank is a vaid Bank
for (uint256 i = 0; i < bankAddresses.length; i++) {
if (msg.sender == bankAddresses[i]) {
//checking if the customer KYC request alreay exist
require(!(kycRequests[_customerData].bank == msg.sender),
"This user already has a KYC request with same data in process.");
kycRequests[_customerData].data_hash = _customerData;
kycRequests[_customerData].userName = _userName;
kycRequests[_customerData].bank = msg.sender;
//incrementing the kyc_count for the bank
banks[msg.sender].kyc_count++;
//checking if the BANK is a trusted bank to add KYC requests
if (banks[msg.sender].rating <= 50) {
kycRequests[_customerData].isAllowed = false;
} else {
kycRequests[_customerData].isAllowed = true;
}
customerDataList.push(_customerData);
return 1;
}
}
return 0; // 0 is returned in case of failure
}
function addCustomer(string memory _userName, string memory _customerData)
public
returns (uint8)
{
//checking if the bank is a vaid Bank
for (uint256 i = 0; i < bankAddresses.length; i++) {
if (msg.sender == bankAddresses[i]) {
//checking if the customerdata hash is valid
for (uint256 k = 0; k < customerDataList.length; k++) {
if (stringsEquals(customerDataList[k], _customerData)) {
require(customers[_userName].bank == address(0),
"This customer is already present, modifyCustomer to edit the customer data");
require(kycRequests[_customerData].isAllowed == true,
"isAllowed is false, bank is not trusted to perfrom the transaction");
customers[_userName].userName = _userName;
customers[_userName].data_hash = _customerData;
customers[_userName].bank = msg.sender;
customers[_userName].upvotes = 0;
customerNames.push(_userName);
return 1;
}
}
}
}
return 0; // 0 is returned in case of failure
}
function removeKYCRequest(string memory _userName,
string memory customerData) public returns (uint8) {
uint8 i = 0;
//checking if the provided username and customer Data are mapped in kycRequests
require((stringsEquals(kycRequests[customerData].userName, _userName)),
"Please enter valid UserName and Customer Data Hash");
for (i = 0; i < customerDataList.length; i++) {
if (stringsEquals(customerDataList[i], customerData)) {
delete kycRequests[customerData];
for (uint256 j = i + 1; j < customerDataList.length; j++) {
customerDataList[j - 1] = customerDataList[j];
}
customerDataList.length--;
return 1;
}
}
return 0; // 0 is returned if no request with the input username is found.
}
function removeCustomer(string memory _userName) public returns (uint8) {
//checking if the customer is present in the customers list
for (uint256 i = 0; i < customerNames.length; i++) {
if (stringsEquals(customerNames[i], _userName)) {
delete customers[_userName];
//removing the customer from customerNames array
for (uint256 j = i + 1; j < customerNames.length; j++) {
customerNames[j - 1] = customerNames[j];
}
customerNames.length--;
return 1;
}
}
return 0;
}
function viewCustomer(string memory _userName, string memory password)
public
view
returns (string memory)
{
//looping through customerNames to check if the _userName passes is valid
for (uint256 i = 0; i < customerNames.length; i++) {
if (stringsEquals(customerNames[i], _userName)) {
for (uint256 k = 0; k < passwordSet.length; k++) {
if (stringsEquals(passwordSet[k], _userName)) {
//no changes required
continue;
} else {
password = "0";
}
}
}
}
//else error is thrown informing user that password provided didn't match
if (stringsEquals(passwordStore[_userName], password)) {
return customers[_userName].data_hash;
} else {
return "password provided by the user didn't match";
}
}
function upvoteCustomer(string memory _userName) public returns (uint8) {
//checking if the customer exist in the customerNames
for (uint256 i = 0; i < customerNames.length; i++) {
if (stringsEquals(customerNames[i], _userName)) {
require(upvotes[_userName][msg.sender] == 0,
"This bank have already upvoted this customer");
upvotes[_userName][msg.sender] = 1;
customers[_userName].upvotes++;
//updating the rating of the customer
customers[_userName].rating =
(customers[_userName].upvotes * 100) /
bankAddresses.length;
//if the customer rating is higher then also adding the customer to the final_customers list.
if (customers[_userName].rating > 50) {
final_customers[_userName].userName = _userName;
final_customers[_userName].data_hash = customers[_userName]
.data_hash;
final_customers[_userName].rating = customers[_userName]
.rating;
final_customers[_userName].upvotes = customers[_userName]
.upvotes;
final_customers[_userName].bank = customers[_userName].bank;
//final_customerNames is array to itterate over customers
final_customerNames.push(_userName);
}
return 1;
}
}
return 0;
}
function modifyCustomer(string memory _userName,
string memory password,
string memory _newcustomerData) public returns (uint8) {
//checking if the user exist
for (uint256 i = 0; i < customerNames.length; i++) {
if (stringsEquals(customerNames[i], _userName)) {
for (uint256 k = 0; k < passwordSet.length; k++) {
if (stringsEquals(passwordSet[k], _userName)) {
continue;
} else {
password = "0";
}
}
if (stringsEquals(passwordStore[_userName], password)) {
customers[_userName].data_hash = _newcustomerData;
customers[_userName].bank = msg.sender;
for (uint8 j = 0; i < final_customerNames.length; j++) {
if (stringsEquals(final_customerNames[i], _userName)) {
delete final_customers[_userName];
customers[_userName].rating = 0;
customers[_userName].upvotes = 0;
for (uint256 k = i + 1;
j < final_customerNames.length;
k++) {
final_customerNames[j -
1] = final_customerNames[j];
}
final_customerNames.length--;
}
}
return 1;
}
}
}
return 0;
}
//Array to count number of invalidated KYC requests and store its customer data hash.
string[] KYC_UnValidatedCount;
function getBankRequset(address bankAddress, uint256 index)
public
returns (string memory,
string memory,
address,
bool)
{
//looping through bankAddresses array to check if the passed bankAddress is valid
for (uint256 i = 0; i < bankAddresses.length; i++) {
if (bankAddresses[i] == bankAddress) {
for (uint256 k = 0; k < customerDataList.length; k++) {
//kycRequests whose isAllowed value is False and bankAddress==bankAddress passed as Parameter
//store it in KYC_UnValidatedCount array.
if ((kycRequests[customerDataList[k]].bank ==
bankAddress) &&
(kycRequests[customerDataList[k]].isAllowed == false)) {
KYC_UnValidatedCount.push(customerDataList[k]);
}
}
}
}
return (kycRequests[KYC_UnValidatedCount[index]].userName,
kycRequests[KYC_UnValidatedCount[index]].data_hash,
kycRequests[KYC_UnValidatedCount[index]].bank,
kycRequests[KYC_UnValidatedCount[index]].isAllowed);
}
mapping(address => mapping(address => uint256)) upvotesBank;
mapping(address => uint256) upvoteCount;
function upvoteBank(address bankAddress) public returns (uint8) {
//checking if the bank exist
for (uint256 i = 0; i < bankAddresses.length; i++) {
if (msg.sender == bankAddresses[i]) {
require(upvotesBank[bankAddress][msg.sender] == 0,
"You have already upvoted this bank");
upvotesBank[bankAddress][msg.sender] = 1;
upvoteCount[bankAddress]++;
banks[bankAddress].rating =
(upvoteCount[bankAddress] * 100) /
bankAddresses.length;
return 0;
}
}
return 1;
}
function getCustomerRating(string memory userName)
public
view
returns (uint256)
{
for (uint256 i = 0; i < customerNames.length; i++) {
if (stringsEquals(customerNames[i], userName))
return customers[userName].rating;
}
}
//checking if the bank exist
function getBankRating(address bankAddress) public view returns (uint256) {
for (uint256 i = 0; i < bankAddresses.length; i++) {
if (bankAddresses[i] == bankAddress) {
return banks[bankAddress].rating;
}
}
}
function retrieveHistory(string memory userName)
public
view
returns (address)
{
for (uint256 i = 0; i < customerNames.length; i++) {
if (stringsEquals(customerNames[i], userName)) {
return customers[userName].bank;
}
}
}
//mapping of username to passwordStore
mapping(string => string) public passwordStore;
string[] public passwordSet;
function setPassword(string memory userName, string memory password)
public
returns (bool)
{
//checking if the user exist
for (uint256 i = 0; i < customerNames.length; i++) {
if (stringsEquals(customerNames[i], userName)) {
passwordStore[userName] = password;
//adding username to passwordSet array to itterate over user whose passwords are set
passwordSet.push(userName);
return true;
}
}
}
function getBankDetail(address bankAddress)
public
view
returns (string memory,
address,
uint256,
uint8,
string memory)
{
//checking if bank exist
for (uint256 i = 0; i < bankAddresses.length; i++) {
if (bankAddresses[i] == bankAddress) {
return (banks[bankAddress].bankName,
banks[bankAddress].ethAddress,
banks[bankAddress].rating,
banks[bankAddress].kyc_count,
banks[bankAddress].regNumber);
}
}
}
function addBank(string memory bankName,
address bankAddress,
string memory bankRegistration) public returns (string memory) {
//checking if the account used to perform add operation is an Admin
require(msg.sender == admin, "You are not an admin");
require(banks[bankAddress].ethAddress == address(0),
"This bank is already added to the samrt contract");
//making sure that the registration number is unique
require(bankRegStore[bankRegistration] == address(0),
"This Registration number is already assocaited with another bank");
//adding bank
banks[bankAddress].bankName = bankName;
banks[bankAddress].ethAddress = bankAddress;
banks[bankAddress].rating = 0;
banks[bankAddress].kyc_count = 0;
banks[bankAddress].regNumber = bankRegistration;
bankAddresses.push(bankAddress);
bankRegStore[bankRegistration] = bankAddress;
return "successful entry of bank to the contract";
}
function removeBank(address bankAddress) public returns (string memory) {
//checking if the account used to perform remove operation is an Admin
require(msg.sender == admin, "You are not an admin");
for (uint256 i = 0; i < bankAddresses.length; i++) {
if (bankAddresses[i] == bankAddress) {
delete banks[bankAddress];
for (uint256 j = i + 1; j < bankAddresses.length; j++) {
bankAddresses[j - 1] = bankAddresses[j];
}
bankAddresses.length--;
return "successful removal of the bank from the contract.";
}
}
return "The bank is already removed from the contract";
}
// if you are using string, you can use the following function to compare two strings
// function to compare two string value
// This is an internal fucntion to compare string values
// @Params - String a and String b are passed as Parameters
function stringsEquals(string storage _a, string memory _b)
internal
view
returns (bool)
{
bytes storage a = bytes(_a);
bytes memory b = bytes(_b);
if (a.length != b.length) return false;
// @todo unroll this loop
for (uint256 i = 0; i < a.length; i++) {
if (a[i] != b[i]) return false;
}
return true;
}
}
| 242,908 | 13,833 |
ba3ce5fee3020560930d80a43a5321ee6e5f206ee94877261976c350b4784765
| 12,555 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x766eeedd3e7ca0719ced7d0a94df4af9258a7e82.sol
| 3,180 | 11,489 |
pragma solidity ^0.5.2;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: uniswap-solidity/contracts/UniswapFactoryInterface.sol
// https://docs.uniswap.io/smart-contract-integration/interface
contract UniswapFactoryInterface {
// Public Variables
address public exchangeTemplate;
uint256 public tokenCount;
// Create Exchange
function createExchange(address token) external returns (address exchange);
// Get Exchange and Token Info
function getExchange(address token) external view returns (address exchange);
function getToken(address exchange) external view returns (address token);
function getTokenWithId(uint256 tokenId) external view returns (address token);
// Never use
function initializeFactory(address template) external;
}
// File: uniswap-solidity/contracts/UniswapExchangeInterface.sol
// https://docs.uniswap.io/smart-contract-integration/interface
contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_tokens, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
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);
function balanceOf(address _owner) external view returns (uint256);
// Never use
function setup(address token_addr) external;
}
// File: uniswap-solidity/contracts/Uniswap.sol
// File: contracts/safe/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
function transferTokens(IERC20 _token,
address _from,
address _to,
uint256 _value) internal {
uint256 oldBalance = _token.balanceOf(_to);
require(_token.transferFrom(_from, _to, _value),
"Failed to transfer tokens.");
require(_token.balanceOf(_to) >= oldBalance.add(_value),
"Balance validation failed after transfer.");
}
function approveTokens(IERC20 _token,
address _spender,
uint256 _value) internal {
uint256 nextAllowance =
_token.allowance(address(this), _spender).add(_value);
require(_token.approve(_spender, nextAllowance),
"Failed to approve exchange withdrawal of tokens.");
require(_token.allowance(address(this), _spender) >= nextAllowance,
"Failed to validate token approval.");
}
}
// File: contracts/safe/SafeExchange.sol
library SafeExchange {
using SafeMath for uint256;
modifier swaps(uint256 _value, IERC20 _token) {
uint256 nextBalance = _token.balanceOf(address(this)).add(_value);
_;
require(_token.balanceOf(address(this)) >= nextBalance,
"Balance validation failed after swap.");
}
function swapTokens(UniswapExchangeInterface _exchange,
uint256 _outValue,
uint256 _inValue,
uint256 _ethValue,
uint256 _deadline,
IERC20 _outToken) internal swaps(_outValue, _outToken) {
_exchange.tokenToTokenSwapOutput(_outValue,
_inValue,
_ethValue,
_deadline,
address(_outToken));
}
function swapEther(UniswapExchangeInterface _exchange,
uint256 _outValue,
uint256 _ethValue,
uint256 _deadline,
IERC20 _outToken) internal swaps(_outValue, _outToken) {
_exchange.ethToTokenSwapOutput.value(_ethValue)(_outValue, _deadline);
}
}
// File: contracts/Unipay.sol
contract Unipay {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using SafeExchange for UniswapExchangeInterface;
UniswapFactoryInterface factory;
IERC20 outToken;
address recipient;
constructor(address _factory, address _recipient, address _token) public {
factory = UniswapFactoryInterface(_factory);
outToken = IERC20(_token);
recipient = _recipient;
}
function price(address _token,
uint256 _value) public view returns (uint256, uint256, UniswapExchangeInterface) {
UniswapExchangeInterface inExchange =
UniswapExchangeInterface(factory.getExchange(_token));
UniswapExchangeInterface outExchange =
UniswapExchangeInterface(factory.getExchange(address(outToken)));
uint256 etherCost = outExchange.getEthToTokenOutputPrice(_value);
uint256 tokenCost = inExchange.getTokenToEthOutputPrice(etherCost);
return (tokenCost, etherCost, inExchange);
}
function price(uint256 _value) public view returns (uint256, UniswapExchangeInterface) {
UniswapExchangeInterface exchange =
UniswapExchangeInterface(factory.getExchange(address(outToken)));
return (exchange.getEthToTokenOutputPrice(_value), exchange);
}
function collect(address _from,
address _token,
uint256 _value,
uint256 _deadline) public {
(uint256 tokenCost,
uint256 etherCost,
UniswapExchangeInterface exchange) = price(_token, _value);
IERC20(_token).transferTokens(_from, address(this), tokenCost);
IERC20(_token).approveTokens(address(exchange), tokenCost);
exchange.swapTokens(_value, tokenCost, etherCost, _deadline, outToken);
outToken.approveTokens(recipient, _value);
}
function pay(uint256 _value,
uint256 _deadline) public payable {
(uint256 etherCost,
UniswapExchangeInterface exchange) = price(_value);
require(msg.value >= etherCost, "Insufficient ether sent.");
exchange.swapEther(_value, etherCost, _deadline, outToken);
outToken.approveTokens(recipient, _value);
msg.sender.transfer(msg.value.sub(etherCost));
}
}
| 213,017 | 13,834 |
6bb00b5a155cd567d7d3fae1465f4464ecf1e269c09eec1eb5795e2d622fb6bf
| 19,810 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/source_code_with_test/0x8cdd0cd56ae24422382c4a6ffef382732f43fe4c.sol
| 4,795 | 18,274 |
pragma solidity 0.5.2;
contract Pool {
address public owner;
function balanceOf(address _who) external view returns (uint256);
function totalSupply() external view returns (uint256 totaSupply);
function getEventful() external view returns (address);
function getData() external view returns (string memory name, string memory symbol, uint256 sellPrice, uint256 buyPrice);
function calcSharePrice() external view returns (uint256);
function getAdminData() external view returns (address, address feeCollector, address dragodAO, uint256 ratio, uint256 transactionFee, uint32 minPeriod);
}
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract RigoToken {
address public minter;
uint256 public totalSupply;
function balanceOf(address _who) external view returns (uint256);
}
interface DragoRegistry {
//EVENTS
event Registered(string name, string symbol, uint256 id, address indexed drago, address indexed owner, address indexed group);
event Unregistered(string indexed name, string indexed symbol, uint256 indexed id);
event MetaChanged(uint256 indexed id, bytes32 indexed key, bytes32 value);
function register(address _drago, string calldata _name, string calldata _symbol, uint256 _dragoId, address _owner) external payable returns (bool);
function unregister(uint256 _id) external;
function setMeta(uint256 _id, bytes32 _key, bytes32 _value) external;
function addGroup(address _group) external;
function setFee(uint256 _fee) external;
function updateOwner(uint256 _id) external;
function updateOwners(uint256[] calldata _id) external;
function upgrade(address _newAddress) external payable; //payable as there is a transfer of value, otherwise opcode might throw an error
function setUpgraded(uint256 _version) external;
function drain() external;
function dragoCount() external view returns (uint256);
function fromId(uint256 _id) external view returns (address drago, string memory name, string memory symbol, uint256 dragoId, address owner, address group);
function fromAddress(address _drago) external view returns (uint256 id, string memory name, string memory symbol, uint256 dragoId, address owner, address group);
function fromName(string calldata _name) external view returns (uint256 id, address drago, string memory symbol, uint256 dragoId, address owner, address group);
function getNameFromAddress(address _pool) external view returns (string memory);
function getSymbolFromAddress(address _pool) external view returns (string memory);
function meta(uint256 _id, bytes32 _key) external view returns (bytes32);
function getGroups() external view returns (address[] memory);
function getFee() external view returns (uint256);
}
interface Inflation {
function mintInflation(address _thePool, uint256 _reward) external returns (bool);
function setInflationFactor(address _group, uint256 _inflationFactor) external;
function setMinimumRigo(uint256 _minimum) external;
function setRigoblock(address _newRigoblock) external;
function setAuthority(address _authority) external;
function setProofOfPerformance(address _pop) external;
function setPeriod(uint256 _newPeriod) external;
function canWithdraw(address _thePool) external view returns (bool);
function getInflationFactor(address _group) external view returns (uint256);
}
contract ReentrancyGuard {
// Locked state of mutex
bool private locked = false;
/// @dev Functions with this modifer cannot be reentered. The mutex will be locked
/// before function execution and unlocked after.
modifier nonReentrant() {
// Ensure mutex is unlocked
require(!locked,
"REENTRANCY_ILLEGAL");
// Lock mutex before function call
locked = true;
// Perform function call
_;
// Unlock mutex after function call
locked = false;
}
}
interface ProofOfPerformanceFace {
function claimPop(uint256 _ofPool) external;
function setRegistry(address _dragoRegistry) external;
function setRigoblockDao(address _rigoblockDao) external;
function setRatio(address _ofGroup, uint256 _ratio) external;
function getPoolData(uint256 _ofPool)
external view
returns (bool active,
address thePoolAddress,
address thePoolGroup,
uint256 thePoolPrice,
uint256 thePoolSupply,
uint256 poolValue,
uint256 epochReward,
uint256 ratio,
uint256 pop);
function getHwm(uint256 _ofPool) external view returns (uint256);
}
/// @title Proof of Performance - Controls parameters of inflation.
/// @author Gabriele Rigo - <gab@rigoblock.com>
// solhint-disable-next-line
contract ProofOfPerformance is
SafeMath,
ReentrancyGuard,
ProofOfPerformanceFace
{
address public RIGOTOKENADDRESS;
address public dragoRegistry;
address public rigoblockDao;
mapping (uint256 => PoolPrice) poolPrice;
mapping (address => Group) groups;
struct PoolPrice {
uint256 highwatermark;
}
struct Group {
uint256 rewardRatio;
}
modifier onlyRigoblockDao() {
require(msg.sender == rigoblockDao,
"ONLY_RIGOBLOCK_DAO");
_;
}
constructor(address _rigoTokenAddress,
address _rigoblockDao,
address _dragoRegistry)
public
{
RIGOTOKENADDRESS = _rigoTokenAddress;
rigoblockDao = _rigoblockDao;
dragoRegistry = _dragoRegistry;
}
/// @dev Allows anyone to allocate the pop reward to pool wizards.
/// @param _ofPool Number of pool id in registry.
function claimPop(uint256 _ofPool)
external
nonReentrant
{
DragoRegistry registry = DragoRegistry(dragoRegistry);
address poolAddress;
(poolAddress, , , , ,) = registry.fromId(_ofPool);
uint256 pop = proofOfPerformanceInternal(_ofPool);
require(pop > 0,
"POP_REWARD_IS_NULL");
(uint256 price,) = getPoolPriceInternal(_ofPool);
poolPrice[_ofPool].highwatermark = price;
require(Inflation(getMinter()).mintInflation(poolAddress, pop),
"MINT_INFLATION_ERROR");
}
/// @dev Allows RigoBlock Dao to update the pools registry.
/// @param _dragoRegistry Address of new registry.
function setRegistry(address _dragoRegistry)
external
onlyRigoblockDao
{
dragoRegistry = _dragoRegistry;
}
/// @dev Allows RigoBlock Dao to update its address.
/// @param _rigoblockDao Address of new dao.
function setRigoblockDao(address _rigoblockDao)
external
onlyRigoblockDao
{
rigoblockDao = _rigoblockDao;
}
/// @dev Allows RigoBlock Dao to set the ratio between assets and performance reward for a group.
/// @param _ofGroup Id of the pool.
/// @param _ratio Id of the pool.
/// @notice onlyRigoblockDao can set ratio.
function setRatio(address _ofGroup,
uint256 _ratio)
external
onlyRigoblockDao
{
require(_ratio <= 10000,
"RATIO_BIGGER_THAN_10000"); //(from 0 to 10000)
groups[_ofGroup].rewardRatio = _ratio;
}
/// @dev Gets data of a pool.
/// @param _ofPool Id of the pool.
/// @return Bool the pool is active.
/// @return address of the pool.
/// @return address of the pool factory.
/// @return price of the pool in wei.
/// @return total supply of the pool in units.
/// @return total value of the pool in wei.
/// @return value of the reward factor or said pool.
/// @return ratio of assets/performance reward (from 0 to 10000).
/// @return value of the pop reward to be claimed in GRGs.
function getPoolData(uint256 _ofPool)
external
view
returns (bool active,
address thePoolAddress,
address thePoolGroup,
uint256 thePoolPrice,
uint256 thePoolSupply,
uint256 poolValue,
uint256 epochReward,
uint256 ratio,
uint256 pop)
{
active = isActiveInternal(_ofPool);
(thePoolAddress, thePoolGroup) = addressFromIdInternal(_ofPool);
(thePoolPrice, thePoolSupply) = getPoolPriceInternal(_ofPool);
(poolValue,) = calcPoolValueInternal(_ofPool);
epochReward = getEpochRewardInternal(_ofPool);
ratio = getRatioInternal(_ofPool);
pop = proofOfPerformanceInternal(_ofPool);
return(active,
thePoolAddress,
thePoolGroup,
thePoolPrice,
thePoolSupply,
poolValue,
epochReward,
ratio,
pop);
}
/// @dev Returns the highwatermark of a pool.
/// @param _ofPool Id of the pool.
/// @return Value of the all-time-high pool nav.
function getHwm(uint256 _ofPool)
external
view
returns (uint256)
{
return poolPrice[_ofPool].highwatermark;
}
/// @dev Returns the reward factor for a pool.
/// @param _ofPool Id of the pool.
/// @return Value of the reward factor.
function getEpochReward(uint256 _ofPool)
external
view
returns (uint256)
{
return getEpochRewardInternal(_ofPool);
}
/// @dev Returns the split ratio of asset and performance reward.
/// @param _ofPool Id of the pool.
/// @return Value of the ratio from 1 to 100.
function getRatio(uint256 _ofPool)
external
view
returns (uint256)
{
return getRatioInternal(_ofPool);
}
/// @dev Returns the proof of performance reward for a pool.
/// @param _ofPool Id of the pool.
/// @return Value of the reward in Rigo tokens.
/// @notice epoch reward should be big enough that it.
/// @notice can be decreased if number of funds increases.
/// @notice should be at least 10^6 (just as pool base) to start with.
/// @notice rigo token has 10^18 decimals.
function proofOfPerformance(uint256 _ofPool)
external
view
returns (uint256)
{
return proofOfPerformanceInternal(_ofPool);
}
/// @dev Checks whether a pool is registered and active.
/// @param _ofPool Id of the pool.
/// @return Bool the pool is active.
function isActive(uint256 _ofPool)
external
view
returns (bool)
{
return isActiveInternal(_ofPool);
}
/// @dev Returns the address and the group of a pool from its id.
/// @param _ofPool Id of the pool.
/// @return Address of the target pool.
/// @return Address of the pool's group.
function addressFromId(uint256 _ofPool)
external
view
returns (address pool,
address group)
{
return (addressFromIdInternal(_ofPool));
}
/// @dev Returns the price a pool from its id.
/// @param _ofPool Id of the pool.
/// @return Price of the pool in wei.
/// @return Number of tokens of a pool (totalSupply).
function getPoolPrice(uint256 _ofPool)
external
view
returns (uint256 thePoolPrice,
uint256 totalTokens)
{
return (getPoolPriceInternal(_ofPool));
}
/// @dev Returns the address and the group of a pool from its id.
/// @param _ofPool Id of the pool.
/// @return Address of the target pool.
/// @return Address of the pool's group.
function calcPoolValue(uint256 _ofPool)
external
view
returns (uint256 aum,
bool success)
{
return (calcPoolValueInternal(_ofPool));
}
/// @dev Returns the reward factor for a pool.
/// @param _ofPool Id of the pool.
/// @return Value of the reward factor.
function getEpochRewardInternal(uint256 _ofPool)
internal
view
returns (uint256)
{
(, address group) = addressFromIdInternal(_ofPool);
return Inflation(getMinter()).getInflationFactor(group);
}
/// @dev Returns the split ratio of asset and performance reward.
/// @param _ofPool Id of the pool.
/// @return Value of the ratio from 1 to 100.
function getRatioInternal(uint256 _ofPool)
internal
view
returns (uint256)
{
(, address group) = addressFromIdInternal(_ofPool);
return groups[group].rewardRatio;
}
/// @dev Returns the address of the Inflation contract.
/// @return Address of the minter/inflation.
function getMinter()
internal
view
returns (address)
{
RigoToken token = RigoToken(RIGOTOKENADDRESS);
return token.minter();
}
/// @dev Returns the proof of performance reward for a pool.
/// @param _ofPool Id of the pool.
/// @return Value of the reward in Rigo tokens.
/// @notice epoch reward should be big enough that it.
/// @notice can be decreased if number of funds increases.
/// @notice should be at least 10^6 (just as pool base) to start with.
/// @notice rigo token has 10^18 decimals.
function proofOfPerformanceInternal(uint256 _ofPool)
internal
view
returns (uint256)
{
uint256 highwatermark = 1000 ether; //initialize variable with arbitrarily high value
if (poolPrice[_ofPool].highwatermark == 0) {
highwatermark = 1 ether;
} else {
highwatermark = poolPrice[_ofPool].highwatermark;
}
(uint256 poolValue,) = calcPoolValueInternal(_ofPool);
require(poolValue != 0,
"POOL_VALUE_NULL");
(uint256 newPrice, uint256 tokenSupply) = getPoolPriceInternal(_ofPool);
require (newPrice >= highwatermark,
"PRICE_LOWER_THAN_HWM");
require (tokenSupply > 0,
"TOKEN_SUPPLY_NULL");
uint256 epochReward = 0;
(address thePoolAddress,) = addressFromIdInternal(_ofPool);
uint256 grgBalance =
RigoToken(RIGOTOKENADDRESS)
.balanceOf(Pool(thePoolAddress)
.owner());
if (grgBalance >= 1 * 10 ** 18) {
epochReward = safeMul(getEpochRewardInternal(_ofPool), 10); // 10x reward if wizard holds 1 GRG
} else {
epochReward = getEpochRewardInternal(_ofPool);
}
uint256 rewardRatio = getRatioInternal(_ofPool);
uint256 prevPrice = highwatermark;
uint256 priceDiff = safeSub(newPrice, prevPrice);
uint256 performanceComponent = safeMul(safeMul(priceDiff, tokenSupply), epochReward);
uint256 performanceReward = safeDiv(safeMul(performanceComponent, rewardRatio), 10000 ether);
uint256 assetsComponent = safeMul(poolValue, epochReward);
uint256 assetsReward = safeDiv(safeMul(assetsComponent, safeSub(10000, rewardRatio)), 10000 ether);
uint256 popReward = safeAdd(performanceReward, assetsReward);
if (popReward >= safeDiv(RigoToken(RIGOTOKENADDRESS).totalSupply(), 10000)) {
return (safeDiv(RigoToken(RIGOTOKENADDRESS).totalSupply(), 10000));
} else {
return (popReward);
}
}
/// @dev Checks whether a pool is registered and active.
/// @param _ofPool Id of the pool.
/// @return Bool the pool is active.
function isActiveInternal(uint256 _ofPool)
internal view
returns (bool)
{
DragoRegistry registry = DragoRegistry(dragoRegistry);
(address thePool, , , , ,) = registry.fromId(_ofPool);
if (thePool != address(0)) {
return true;
}
}
/// @dev Returns the address and the group of a pool from its id.
/// @param _ofPool Id of the pool.
/// @return Address of the target pool.
/// @return Address of the pool's group.
function addressFromIdInternal(uint256 _ofPool)
internal
view
returns (address pool,
address group)
{
DragoRegistry registry = DragoRegistry(dragoRegistry);
(pool, , , , , group) = registry.fromId(_ofPool);
return (pool, group);
}
/// @dev Returns the price a pool from its id.
/// @param _ofPool Id of the pool.
/// @return Price of the pool in wei.
/// @return Number of tokens of a pool (totalSupply).
function getPoolPriceInternal(uint256 _ofPool)
internal
view
returns (uint256 thePoolPrice,
uint256 totalTokens)
{
(address poolAddress,) = addressFromIdInternal(_ofPool);
Pool pool = Pool(poolAddress);
thePoolPrice = pool.calcSharePrice();
totalTokens = pool.totalSupply();
}
/// @dev Returns the address and the group of a pool from its id.
/// @param _ofPool Id of the pool.
/// @return Address of the target pool.
/// @return Address of the pool's group.
function calcPoolValueInternal(uint256 _ofPool)
internal
view
returns (uint256 aum,
bool success)
{
(uint256 price, uint256 supply) = getPoolPriceInternal(_ofPool);
return ((aum = (price * supply / 1000000)), true); //1000000 is the base (decimals)
}
}
| 135,533 | 13,835 |
829848534d0466bb07491598b6c0aff7b1f3c4a6a9eca7461ba96d9ff8ac1f50
| 21,379 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/contracts_BSC/Governance/GNBU.sol
| 5,602 | 21,212 |
pragma solidity =0.8.0;
// ----------------------------------------------------------------------------
// GNBU token main contract (2021)
//
// Symbol : GNBU
// Name : Nimbus Governance Token
// Total supply : 100.000.000 (burnable)
// Decimals : 18
// ----------------------------------------------------------------------------
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
interface IBEP20 {
function totalSupply() external view returns (uint);
function decimals() external view returns (uint8);
function balanceOf(address tokenOwner) external view returns (uint balance);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function getOwner() external view returns (address);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function getOwner() external view returns (address) {
return owner;
}
function transferOwnership(address transferOwner) external onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual external {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
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 GNBU is Ownable, Pausable {
string public constant name = "Nimbus Governance Token";
string public constant symbol = "GNBU";
uint8 public constant decimals = 18;
uint96 public totalSupply = 100_000_000e18; // 100 million GNBU
mapping (address => mapping (address => uint96)) internal allowances;
mapping (address => uint96) private _unfrozenBalances;
mapping (address => uint32) private _vestingNonces;
mapping (address => mapping (uint32 => uint96)) private _vestingAmounts;
mapping (address => mapping (uint32 => uint96)) private _unvestedAmounts;
mapping (address => mapping (uint32 => uint)) private _vestingReleaseStartDates;
mapping (address => bool) public vesters;
uint96 private vestingFirstPeriod = 60 days;
uint96 private vestingSecondPeriod = 152 days;
address[] public supportUnits;
uint public supportUnitsCnt;
mapping (address => address) public delegates;
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
mapping (address => uint32) public numCheckpoints;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
mapping (address => uint) public nonces;
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
event Unvest(address indexed user, uint amount);
constructor() {
_unfrozenBalances[owner] = uint96(totalSupply);
emit Transfer(address(0), owner, totalSupply);
}
receive() payable external {
revert();
}
function freeCirculation() external view returns (uint) {
uint96 systemAmount = _unfrozenBalances[owner];
for (uint i; i < supportUnits.length; i++) {
systemAmount = add96(systemAmount, _unfrozenBalances[supportUnits[i]], "GNBU::freeCirculation: adding overflow");
}
return sub96(totalSupply, systemAmount, "GNBU::freeCirculation: amount exceed totalSupply");
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external whenNotPaused returns (bool) {
require(spender != address(0), "GNBU::approve: approve to the zero address");
uint96 amount;
if (rawAmount == type(uint256).max) {
amount = type(uint96).max;
} else {
amount = safe96(rawAmount, "GNBU::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external whenNotPaused {
uint96 amount;
if (rawAmount == type(uint256).max) {
amount = type(uint96).max;
} else {
amount = safe96(rawAmount, "GNBU::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GNBU::permit: invalid signature");
require(signatory == owner, "GNBU::permit: unauthorized");
require(block.timestamp <= deadline, "GNBU::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) public view returns (uint) {
uint96 amount = _unfrozenBalances[account];
if (_vestingNonces[account] == 0) return amount;
for (uint32 i = 1; i <= _vestingNonces[account]; i++) {
uint96 unvested = sub96(_vestingAmounts[account][i], _unvestedAmounts[account][i], "GNBU::balanceOf: unvested exceed vested amount");
amount = add96(amount, unvested, "GNBU::balanceOf: overflow");
}
return amount;
}
function availableForUnvesting(address user) external view returns (uint unvestAmount) {
if (_vestingNonces[user] == 0) return 0;
for (uint32 i = 1; i <= _vestingNonces[user]; i++) {
if (_vestingAmounts[user][i] == _unvestedAmounts[user][i]) continue;
if (_vestingReleaseStartDates[user][i] > block.timestamp) break;
uint toUnvest = (block.timestamp - _vestingReleaseStartDates[user][i]) * _vestingAmounts[user][i] / vestingSecondPeriod;
if (toUnvest > _vestingAmounts[user][i]) {
toUnvest = _vestingAmounts[user][i];
}
toUnvest -= _unvestedAmounts[user][i];
unvestAmount += toUnvest;
}
}
function availableForTransfer(address account) external view returns (uint) {
return _unfrozenBalances[account];
}
function vestingInfo(address user, uint32 nonce) external view returns (uint vestingAmount, uint unvestedAmount, uint vestingReleaseStartDate) {
vestingAmount = _vestingAmounts[user][nonce];
unvestedAmount = _unvestedAmounts[user][nonce];
vestingReleaseStartDate = _vestingReleaseStartDates[user][nonce];
}
function vestingNonces(address user) external view returns (uint lastNonce) {
return _vestingNonces[user];
}
function transfer(address dst, uint rawAmount) external whenNotPaused returns (bool) {
uint96 amount = safe96(rawAmount, "GNBU::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external whenNotPaused returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "GNBU::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != type(uint96).max) {
uint96 newAllowance = sub96(spenderAllowance, amount, "GNBU::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 whenNotPaused {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public whenNotPaused {
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), "GNBU::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "GNBU::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "GNBU::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function unvest() external whenNotPaused returns (uint unvested) {
require (_vestingNonces[msg.sender] > 0, "GNBU::unvest:No vested amount");
for (uint32 i = 1; i <= _vestingNonces[msg.sender]; i++) {
if (_vestingAmounts[msg.sender][i] == _unvestedAmounts[msg.sender][i]) continue;
if (_vestingReleaseStartDates[msg.sender][i] > block.timestamp) break;
uint toUnvest = (block.timestamp - _vestingReleaseStartDates[msg.sender][i]) * _vestingAmounts[msg.sender][i] / vestingSecondPeriod;
if (toUnvest > _vestingAmounts[msg.sender][i]) {
toUnvest = _vestingAmounts[msg.sender][i];
}
uint totalUnvestedForNonce = toUnvest;
require(toUnvest >= _unvestedAmounts[msg.sender][i], "GNBU::unvest: already unvested amount exceeds toUnvest");
toUnvest -= _unvestedAmounts[msg.sender][i];
unvested += toUnvest;
_unvestedAmounts[msg.sender][i] = safe96(totalUnvestedForNonce, "GNBU::unvest: amount exceeds 96 bits");
}
_unfrozenBalances[msg.sender] = add96(_unfrozenBalances[msg.sender], safe96(unvested, "GNBU::unvest: amount exceeds 96 bits"), "GNBU::unvest: adding overflow");
emit Unvest(msg.sender, unvested);
}
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, "GNBU::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 = _unfrozenBalances[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), "GNBU::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "GNBU::_transferTokens: cannot transfer to the zero address");
_unfrozenBalances[src] = sub96(_unfrozenBalances[src], amount, "GNBU::_transferTokens: transfer amount exceeds balance");
_unfrozenBalances[dst] = add96(_unfrozenBalances[dst], amount, "GNBU::_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, "GNBU::_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, "GNBU::_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, "GNBU::_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 _vest(address user, uint96 amount) private {
require(user != address(0), "GNBU::_vest: vest to the zero address");
uint32 nonce = ++_vestingNonces[user];
_vestingAmounts[user][nonce] = amount;
_vestingReleaseStartDates[user][nonce] = block.timestamp + vestingFirstPeriod;
_unfrozenBalances[owner] = sub96(_unfrozenBalances[owner], amount, "GNBU::_vest: exceeds owner balance");
emit Transfer(owner, user, amount);
}
function burnTokens(uint rawAmount) public onlyOwner returns (bool success) {
uint96 amount = safe96(rawAmount, "GNBU::burnTokens: amount exceeds 96 bits");
require(amount <= _unfrozenBalances[owner]);
_unfrozenBalances[owner] = sub96(_unfrozenBalances[owner], amount, "GNBU::burnTokens: transfer amount exceeds balance");
totalSupply = sub96(totalSupply, amount, "GNBU::burnTokens: transfer amount exceeds total supply");
emit Transfer(owner, address(0), amount);
return true;
}
function vest(address user, uint rawAmount) external {
require (vesters[msg.sender], "GNBU::vest: not vester");
uint96 amount = safe96(rawAmount, "GNBU::vest: amount exceeds 96 bits");
_vest(user, amount);
}
function multisend(address[] memory to, uint[] memory values) public onlyOwner returns (uint) {
require(to.length == values.length);
require(to.length < 100);
uint sum;
for (uint j; j < values.length; j++) {
sum += values[j];
}
uint96 _sum = safe96(sum, "GNBU::transfer: amount exceeds 96 bits");
_unfrozenBalances[owner] = sub96(_unfrozenBalances[owner], _sum, "GNBU::_transferTokens: transfer amount exceeds balance");
for (uint i; i < to.length; i++) {
_unfrozenBalances[to[i]] = add96(_unfrozenBalances[to[i]], uint96(values[i]), "GNBU::_transferTokens: transfer amount exceeds balance");
emit Transfer(owner, to[i], values[i]);
}
return(to.length);
}
function multivest(address[] memory to, uint[] memory values) external onlyOwner returns (uint) {
require(to.length == values.length);
require(to.length < 100);
uint sum;
for (uint j; j < values.length; j++) {
sum += values[j];
}
uint96 _sum = safe96(sum, "GNBU::multivest: amount exceeds 96 bits");
_unfrozenBalances[owner] = sub96(_unfrozenBalances[owner], _sum, "GNBU::multivest: transfer amount exceeds balance");
for (uint i; i < to.length; i++) {
uint32 nonce = ++_vestingNonces[to[i]];
_vestingAmounts[to[i]][nonce] = uint96(values[i]);
_vestingReleaseStartDates[to[i]][nonce] = block.timestamp + vestingFirstPeriod;
emit Transfer(owner, to[i], values[i]);
}
return(to.length);
}
function transferAnyBEP20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return IBEP20(tokenAddress).transfer(owner, tokens);
}
function updateVesters(address vester, bool isActive) external onlyOwner {
vesters[vester] = isActive;
}
function acceptOwnership() public override {
require(msg.sender == newOwner);
uint96 amount = _unfrozenBalances[owner];
_transferTokens(owner, newOwner, amount);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function updateSupportUnitAdd(address newSupportUnit) external onlyOwner {
for (uint i; i < supportUnits.length; i++) {
require (supportUnits[i] != newSupportUnit, "GNBU::updateSupportUnitAdd: support unit exists");
}
supportUnits.push(newSupportUnit);
supportUnitsCnt++;
}
function updateSupportUnitRemove(uint supportUnitIndex) external onlyOwner {
supportUnits[supportUnitIndex] = supportUnits[supportUnits.length - 1];
supportUnits.pop();
supportUnitsCnt--;
}
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 view returns (uint) {
return block.chainid;
}
function mul96(uint96 a, uint96 b) internal pure returns (uint96) {
if (a == 0) {
return 0;
}
uint96 c = a * b;
require(c / a == b, "GNBU:mul96: multiplication overflow");
return c;
}
function mul96(uint256 a, uint96 b) internal pure returns (uint96) {
uint96 _a = safe96(a, "GNBU:mul96: amount exceeds uint96");
if (_a == 0) {
return 0;
}
uint96 c = _a * b;
require(c / _a == b, "GNBU:mul96: multiplication overflow");
return c;
}
}
| 236,117 | 13,836 |
ee05a1fda84926680fa5a022680db8c8a21db92a2cf66ede90fc6d78f2cc5b4f
| 11,329 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x30487380ff0727521884053d8842007791a998d9.sol
| 2,775 | 10,208 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract SuperOwners {
address public owner1;
address public pendingOwner1;
address public owner2;
address public pendingOwner2;
function SuperOwners(address _owner1, address _owner2) internal {
require(_owner1 != address(0));
owner1 = _owner1;
require(_owner2 != address(0));
owner2 = _owner2;
}
modifier onlySuperOwner1() {
require(msg.sender == owner1);
_;
}
modifier onlySuperOwner2() {
require(msg.sender == owner2);
_;
}
modifier onlySuperOwner() {
require(isSuperOwner(msg.sender));
_;
}
function isSuperOwner(address _addr) public view returns (bool) {
return _addr == owner1 || _addr == owner2;
}
function transferOwnership1(address _newOwner1) onlySuperOwner1 public {
pendingOwner1 = _newOwner1;
}
function transferOwnership2(address _newOwner2) onlySuperOwner2 public {
pendingOwner2 = _newOwner2;
}
function claimOwnership1() public {
require(msg.sender == pendingOwner1);
owner1 = pendingOwner1;
pendingOwner1 = address(0);
}
function claimOwnership2() public {
require(msg.sender == pendingOwner2);
owner2 = pendingOwner2;
pendingOwner2 = address(0);
}
}
contract MultiOwnable is SuperOwners {
mapping (address => bool) public ownerMap;
address[] public ownerHistory;
event OwnerAddedEvent(address indexed _newOwner);
event OwnerRemovedEvent(address indexed _oldOwner);
function MultiOwnable(address _owner1, address _owner2)
SuperOwners(_owner1, _owner2) internal {}
modifier onlyOwner() {
require(isOwner(msg.sender));
_;
}
function isOwner(address owner) public view returns (bool) {
return isSuperOwner(owner) || ownerMap[owner];
}
function ownerHistoryCount() public view returns (uint) {
return ownerHistory.length;
}
// Add extra owner
function addOwner(address owner) onlySuperOwner public {
require(owner != address(0));
require(!ownerMap[owner]);
ownerMap[owner] = true;
ownerHistory.push(owner);
OwnerAddedEvent(owner);
}
// Remove extra owner
function removeOwner(address owner) onlySuperOwner public {
require(ownerMap[owner]);
ownerMap[owner] = false;
OwnerRemovedEvent(owner);
}
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address _owner) public view 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 view 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 ERC20 {
using SafeMath for uint;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 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;
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0);
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract CommonToken is StandardToken, MultiOwnable {
string public name;
string public symbol;
uint256 public totalSupply;
uint8 public decimals = 18;
string public version = 'v0.1';
address public seller; // The main account that holds all tokens at the beginning and during tokensale.
uint256 public saleLimit; // (e18) How many tokens can be sold in total through all tiers or tokensales.
uint256 public tokensSold; // (e18) Number of tokens sold through all tiers or tokensales.
uint256 public totalSales; // Total number of sales (including external sales) made through all tiers or tokensales.
// Lock the transfer functions during tokensales to prevent price speculations.
bool public locked = true;
event SellEvent(address indexed _seller, address indexed _buyer, uint256 _value);
event ChangeSellerEvent(address indexed _oldSeller, address indexed _newSeller);
event Burn(address indexed _burner, uint256 _value);
event Unlock();
function CommonToken(address _owner1,
address _owner2,
address _seller,
string _name,
string _symbol,
uint256 _totalSupplyNoDecimals,
uint256 _saleLimitNoDecimals) MultiOwnable(_owner1, _owner2) public {
require(_seller != address(0));
require(_totalSupplyNoDecimals > 0);
require(_saleLimitNoDecimals > 0);
seller = _seller;
name = _name;
symbol = _symbol;
totalSupply = _totalSupplyNoDecimals * 1e18;
saleLimit = _saleLimitNoDecimals * 1e18;
balances[seller] = totalSupply;
Transfer(0x0, seller, totalSupply);
}
modifier ifUnlocked(address _from, address _to) {
require(!locked || isOwner(_from) || isOwner(_to));
_;
}
function unlock() onlySuperOwner public {
require(locked);
locked = false;
Unlock();
}
function changeSeller(address newSeller) onlySuperOwner public returns (bool) {
require(newSeller != address(0));
require(seller != newSeller);
address oldSeller = seller;
uint256 unsoldTokens = balances[oldSeller];
balances[oldSeller] = 0;
balances[newSeller] = balances[newSeller].add(unsoldTokens);
Transfer(oldSeller, newSeller, unsoldTokens);
seller = newSeller;
ChangeSellerEvent(oldSeller, newSeller);
return true;
}
function sellNoDecimals(address _to, uint256 _value) public returns (bool) {
return sell(_to, _value * 1e18);
}
function sell(address _to, uint256 _value) onlyOwner public returns (bool) {
// Check that we are not out of limit and still can sell tokens:
require(tokensSold.add(_value) <= saleLimit);
require(_to != address(0));
require(_value > 0);
require(_value <= balances[seller]);
balances[seller] = balances[seller].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(seller, _to, _value);
totalSales++;
tokensSold = tokensSold.add(_value);
SellEvent(seller, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) ifUnlocked(msg.sender, _to) public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) ifUnlocked(_from, _to) public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function burn(uint256 _value) public returns (bool) {
require(_value > 0);
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value) ;
totalSupply = totalSupply.sub(_value);
Transfer(msg.sender, 0x0, _value);
Burn(msg.sender, _value);
return true;
}
}
contract RaceToken is CommonToken {
function RaceToken() CommonToken(0x229B9Ef80D25A7e7648b17e2c598805d042f9e56, // __OWNER1__
0xcd7cF1D613D5974876AfBfd612ED6AFd94093ce7, // __OWNER2__
0x2821e1486D604566842FF27F626aF133FddD5f89, // __SELLER__
'Coin Race',
'RACE',
100 * 1e6, // 100m tokens in total.
70 * 1e6 // 70m tokens for sale.) public {}
}
| 335,512 | 13,837 |
b1988d3bb6a04fe41f8809fd88d92d53cbb202f5affeb7bf09bd5ffaff64ecc8
| 11,882 |
.sol
|
Solidity
| false |
413220743
|
ghoul-sol/treasure-staking
|
0bf0fb941e76b53de22565055f2a7ec816a5779a
|
contracts/TreasuryStake.sol
| 3,645 | 11,837 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/utils/math/SafeCast.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';
contract TreasuryStake is ERC1155Holder {
using SafeERC20 for ERC20;
using SafeCast for uint256;
using SafeCast for int256;
uint256 public constant DAY = 60 * 60 * 24;
uint256 public constant ONE_WEEK = DAY * 7;
uint256 public constant TWO_WEEKS = ONE_WEEK * 2;
uint256 public constant ONE_MONTH = DAY * 30;
uint256 public constant THREE_MONTHS = ONE_MONTH * 3;
uint256 public constant LIFECYCLE = THREE_MONTHS;
uint256 public constant ONE = 1e18;
// Magic token addr
ERC20 public immutable magic;
IERC1155 public immutable lpToken;
uint256 public totalRewardsEarned;
uint256 public accMagicPerShare;
uint256 public totalLpToken;
uint256 public undistributedRewards;
struct UserInfo {
uint256 depositAmount;
uint256 tokenId;
uint256 lpAmount;
int256 rewardDebt;
}
/// @notice user => tokenId => UserInfo
mapping (address => mapping (uint256 => UserInfo)) public userInfo;
/// @notice user => tokenId[]
mapping (address => uint256[]) public allUserTokenIds;
// @notice user => tokenId => index in allUserIndex
mapping (address => mapping(uint256 => uint256)) public tokenIdIndex;
event Deposit(address indexed user, uint256 lpAmount, uint256 tokenId, uint256 depositAmount);
event Withdraw(address indexed user, uint256 tokenId, uint256 withdrawAmount);
event Harvest(address indexed user, uint256 indexed index, uint256 amount);
event LogUpdateRewards(uint256 lpSupply, uint256 accMagicPerShare);
constructor(address _magic, address _lpToken) {
magic = ERC20(_magic);
lpToken = IERC1155(_lpToken);
}
function getLpAmount(uint256 _tokenId, uint256 _amount) public pure returns (uint256) {
uint256 boost;
uint256 boostDecimal = 100;
if (_tokenId == 39) { // Ancient Relic 10.03
boost = 1003;
} else if (_tokenId == 46) { // Bag of Rare Mushrooms 8.21
boost = 821;
} else if (_tokenId == 47) { // Bait for Monsters 9.73
boost = 973;
} else if (_tokenId == 48) { // Beetle-wing 1.00
boost = 100;
} else if (_tokenId == 49) { // Blue Rupee 2.04
boost = 204;
} else if (_tokenId == 51) { // Bottomless Elixir 10.15
boost = 1015;
} else if (_tokenId == 52) { // Cap of Invisibility 10.15
boost = 1015;
} else if (_tokenId == 53) { // Carriage 8.09
boost = 809;
} else if (_tokenId == 54) { // Castle 9.77
boost = 977;
} else if (_tokenId == 68) { // Common Bead 7.52
boost = 752;
} else if (_tokenId == 69) { // Common Feather 4.50
boost = 450;
} else if (_tokenId == 71) { // Common Relic 2.87
boost = 287;
} else if (_tokenId == 72) { // Cow 7.74
boost = 774;
} else if (_tokenId == 73) { // Diamond 1.04
boost = 104;
} else if (_tokenId == 74) { // Divine Hourglass 8.46
boost = 846;
} else if (_tokenId == 75) { // Divine Mask 7.62
boost = 762;
} else if (_tokenId == 76) { // Donkey 1.62
boost = 162;
} else if (_tokenId == 77) { // Dragon Tail 1.03
boost = 103;
} else if (_tokenId == 79) { // Emerald 1.01
boost = 101;
} else if (_tokenId == 82) { // Favor from the Gods 7.39
boost = 739;
} else if (_tokenId == 91) { // Framed Butterfly 7.79
boost = 779;
} else if (_tokenId == 92) { // Gold Coin 1.03
boost = 103;
} else if (_tokenId == 93) { // Grain 4.29
boost = 429;
} else if (_tokenId == 94) { // Green Rupee 4.36
boost = 436;
} else if (_tokenId == 95) { // Grin 10.47
boost = 1047;
} else if (_tokenId == 96) { // Half-Penny 1.05
boost = 105;
} else if (_tokenId == 97) { // Honeycomb 10.52
boost = 1052;
} else if (_tokenId == 98) { // Immovable Stone 9.65
boost = 965;
} else if (_tokenId == 99) { // Ivory Breastpin 8.49
boost = 849;
} else if (_tokenId == 100) { // Jar of Fairies 7.10
boost = 710;
} else if (_tokenId == 103) { // Lumber 4.02
boost = 402;
} else if (_tokenId == 104) { // Military Stipend 8.30
boost = 830;
} else if (_tokenId == 105) { // Mollusk Shell 8.96
boost = 896;
} else if (_tokenId == 114) { // Ox 2.12
boost = 212;
} else if (_tokenId == 115) { // Pearl 1.03
boost = 103;
} else if (_tokenId == 116) { // Pot of Gold 7.72
boost = 772;
} else if (_tokenId == 117) { // Quarter-Penny 1.00
boost = 100;
} else if (_tokenId == 132) { // Red Feather 8.51
boost = 851;
} else if (_tokenId == 133) { // Red Rupee 1.03
boost = 103;
} else if (_tokenId == 141) { // Score of Ivory 7.94
boost = 794;
} else if (_tokenId == 151) { // Silver Coin 1.05
boost = 105;
} else if (_tokenId == 152) { // Small Bird 7.98
boost = 798;
} else if (_tokenId == 153) { // Snow White Feather 8.54
boost = 854;
} else if (_tokenId == 161) { // Thread of Divine Silk 9.77
boost = 977;
} else if (_tokenId == 162) { // Unbreakable Pocketwatch 7.91
boost = 791;
} else if (_tokenId == 164) { // Witches Broom 6.76
boost = 676;
} else {
boost = 0;
}
_amount = addDecimals(_amount);
return _amount + _amount * boost / boostDecimal;
}
function addDecimals(uint256 _amount) public pure returns (uint256) {
return _amount * ONE;
}
function getAllUserTokenIds(address _user) public view returns (uint256[] memory) {
return allUserTokenIds[_user];
}
function pendingRewardsPosition(address _user, uint256 _tokenId) public view returns (uint256 pending) {
UserInfo storage user = userInfo[_user][_tokenId];
pending = ((user.lpAmount * accMagicPerShare / ONE).toInt256() - user.rewardDebt).toUint256();
}
function pendingRewardsAll(address _user) external view returns (uint256 pending) {
uint256 len = allUserTokenIds[_user].length;
for (uint256 i = 0; i < len; ++i) {
uint256 tokenId = allUserTokenIds[_user][i];
pending += pendingRewardsPosition(_user, tokenId);
}
}
function deposit(uint256 _tokenId, uint256 _amount) public {
UserInfo storage user = _addDeposit(msg.sender, _tokenId);
uint256 lpAmount = getLpAmount(_tokenId, _amount);
totalLpToken += lpAmount;
user.tokenId = _tokenId;
user.depositAmount += _amount;
user.lpAmount += lpAmount;
user.rewardDebt += (lpAmount * accMagicPerShare / ONE).toInt256();
lpToken.safeTransferFrom(msg.sender, address(this), _tokenId, _amount, bytes(""));
emit Deposit(msg.sender, lpAmount, _tokenId, _amount);
}
function withdrawPosition(uint256 _tokenId, uint256 _amount) public {
UserInfo storage user = userInfo[msg.sender][_tokenId];
uint256 lpAmount = user.lpAmount;
uint256 depositAmount = user.depositAmount;
require(depositAmount > 0, "Position does not exists");
if (_amount > depositAmount) {
_amount = depositAmount;
}
// Effects
uint256 ratio = _amount * ONE / depositAmount;
lpAmount = lpAmount * ratio / ONE;
totalLpToken -= lpAmount;
user.depositAmount -= _amount;
user.lpAmount -= lpAmount;
user.rewardDebt -= (lpAmount * accMagicPerShare / ONE).toInt256();
// Interactions
lpToken.safeTransferFrom(address(this), msg.sender, _tokenId, _amount, bytes(""));
emit Withdraw(msg.sender, _tokenId, _amount);
}
function withdrawAll() public {
uint256[] memory tokenIds = allUserTokenIds[msg.sender];
uint256 len = tokenIds.length;
for (uint256 i = 0; i < len; ++i) {
uint256 tokenId = tokenIds[i];
withdrawPosition(tokenId, type(uint256).max);
}
}
function harvestPosition(uint256 _tokenId) public {
UserInfo storage user = userInfo[msg.sender][_tokenId];
int256 accumulatedMagic = (user.lpAmount * accMagicPerShare / ONE).toInt256();
uint256 _pendingMagic = (accumulatedMagic - user.rewardDebt).toUint256();
// Effects
user.rewardDebt = accumulatedMagic;
if (user.lpAmount == 0) {
_removeDeposit(msg.sender, _tokenId);
}
// Interactions
if (_pendingMagic != 0) {
magic.safeTransfer(msg.sender, _pendingMagic);
}
emit Harvest(msg.sender, _tokenId, _pendingMagic);
}
function harvestAll() public {
uint256[] memory tokenIds = allUserTokenIds[msg.sender];
uint256 len = tokenIds.length;
for (uint256 i = 0; i < len; ++i) {
uint256 tokenId = tokenIds[i];
harvestPosition(tokenId);
}
}
function withdrawAndHarvestPosition(uint256 _tokenId, uint256 _amount) public {
withdrawPosition(_tokenId, _amount);
harvestPosition(_tokenId);
}
function withdrawAndHarvestAll() public {
uint256[] memory tokenIds = allUserTokenIds[msg.sender];
uint256 len = tokenIds.length;
for (uint256 i = 0; i < len; ++i) {
uint256 tokenId = tokenIds[i];
withdrawAndHarvestPosition(tokenId, type(uint256).max);
}
}
function notifyRewards(uint256 _amount) external {
if (_amount != 0) magic.safeTransferFrom(msg.sender, address(this), _amount);
_updateRewards(_amount);
}
function _updateRewards(uint256 _amount) internal {
uint256 lpSupply = totalLpToken;
if (lpSupply > 0) {
uint256 magicReward = _amount + undistributedRewards;
accMagicPerShare += magicReward * ONE / lpSupply;
undistributedRewards = 0;
} else {
undistributedRewards += _amount;
}
emit LogUpdateRewards(lpSupply, accMagicPerShare);
}
function _addDeposit(address _user, uint256 _tokenId) internal returns (UserInfo storage user) {
user = userInfo[_user][_tokenId];
uint256 tokenIndex = tokenIdIndex[_user][_tokenId];
if (allUserTokenIds[_user].length == 0 || allUserTokenIds[_user][tokenIndex] != _tokenId) {
tokenIdIndex[_user][_tokenId] = allUserTokenIds[_user].length;
allUserTokenIds[_user].push(_tokenId);
}
}
function _removeDeposit(address _user, uint256 _tokenId) internal {
uint256 tokenIndex = tokenIdIndex[_user][_tokenId];
require(allUserTokenIds[_user][tokenIndex] == _tokenId, 'tokenId !exists');
uint256 lastDepositIndex = allUserTokenIds[_user].length - 1;
if (tokenIndex != lastDepositIndex) {
uint256 lastDepositId = allUserTokenIds[_user][lastDepositIndex];
allUserTokenIds[_user][tokenIndex] = lastDepositId;
tokenIdIndex[_user][lastDepositId] = tokenIndex;
}
allUserTokenIds[_user].pop();
delete tokenIdIndex[_user][_tokenId];
}
}
| 243,741 | 13,838 |
2c7e68812d396b3855ea8a674c5b214666d67124751d28eb962e49ac0499f074
| 27,531 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/bb/bb7B4187154684e6aEf2033EB410789D98b528bf_SkadiStaking.sol
| 4,255 | 16,999 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface ISSKI {
function rebase(uint256 skiProfit_, 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 SkadiStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Ski;
address public immutable sSki;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Ski,
address _sSki,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Ski != address(0));
Ski = _Ski;
require(_sSki != address(0));
sSki = _sSki;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Ski).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(ISSKI(sSki).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sSki).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, ISSKI(sSki).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), ISSKI(sSki).balanceForGons(info.gons));
IERC20(Ski).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(sSki).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Ski).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return ISSKI(sSki).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
ISSKI(sSki).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = ISSKI(sSki).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Ski).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sSki).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sSki).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
function resetEpochEndTime(uint32 _firstEpochTime) external onlyManager() {
epoch.endTime = _firstEpochTime;
}
}
| 126,791 | 13,839 |
aa4c755df0de75b026c3025dcc61097e960a6d233e4c2e7a80ca118753074c11
| 15,172 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xee5fe244406f35d9b4ddb488a64d51456630befc.sol
| 3,613 | 13,544 |
pragma solidity ^0.4.21;
contract ERC20Interface {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint256);
}
contract ERC20Token is ERC20Interface {
using SafeMath for uint256;
// Total amount of tokens issued
uint256 internal totalTokenIssued;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) internal allowed;
function totalSupply() public view returns (uint256) {
return totalTokenIssued;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return (size > 0);
}
function transfer(address _to, uint256 _amount) public returns (bool) {
require(_to != address(0x0));
// Do not allow to transfer token to contract address to avoid tokens getting stuck
require(isContract(_to) == false);
// amount sent cannot exceed balance
require(balances[msg.sender] >= _amount);
// update balances
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
emit Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint256 _amount) public returns (bool) {
require(_spender != address(0x0));
// update allowed amount
allowed[msg.sender][_spender] = _amount;
// log event
emit Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool) {
require(_to != address(0x0));
// Do not allow to transfer token to contract address to avoid tokens getting stuck
require(isContract(_to) == false);
// balance checks
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
// update balances and allowed amount
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
emit Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
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
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 WhiteListManager is Ownable {
// The list here will be updated by multiple separate WhiteList contracts
mapping (address => bool) public list;
function unset(address addr) public onlyOwner {
list[addr] = false;
}
function unsetMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
unset(addrList[i]);
}
}
function set(address addr) public onlyOwner {
list[addr] = true;
}
function setMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
set(addrList[i]);
}
}
function isWhitelisted(address addr) public view returns (bool) {
return list[addr];
}
}
contract ShareToken is ERC20Token, WhiteListManager {
using SafeMath for uint256;
string public constant name = "ShareToken";
string public constant symbol = "SHR";
uint8 public constant decimals = 2;
address public icoContract;
// Any token amount must be multiplied by this const to reflect decimals
uint256 constant E2 = 10**2;
mapping(address => bool) public rewardTokenLocked;
bool public mainSaleTokenLocked = true;
uint256 public constant TOKEN_SUPPLY_MAINSALE_LIMIT = 1000000000 * E2; // 1,000,000,000 tokens (1 billion)
uint256 public constant TOKEN_SUPPLY_AIRDROP_LIMIT = 6666666667; // 66,666,666.67 tokens (0.066 billion)
uint256 public constant TOKEN_SUPPLY_BOUNTY_LIMIT = 33333333333; // 333,333,333.33 tokens (0.333 billion)
uint256 public airDropTokenIssuedTotal;
uint256 public bountyTokenIssuedTotal;
uint256 public constant TOKEN_SUPPLY_SEED_LIMIT = 500000000 * E2; // 500,000,000 tokens (0.5 billion)
uint256 public constant TOKEN_SUPPLY_PRESALE_LIMIT = 2500000000 * E2; // 2,500,000,000.00 tokens (2.5 billion)
uint256 public constant TOKEN_SUPPLY_SEED_PRESALE_LIMIT = TOKEN_SUPPLY_SEED_LIMIT + TOKEN_SUPPLY_PRESALE_LIMIT;
uint256 public seedAndPresaleTokenIssuedTotal;
uint8 private constant PRESALE_EVENT = 0;
uint8 private constant MAINSALE_EVENT = 1;
uint8 private constant BOUNTY_EVENT = 2;
uint8 private constant AIRDROP_EVENT = 3;
function ShareToken() public {
totalTokenIssued = 0;
airDropTokenIssuedTotal = 0;
bountyTokenIssuedTotal = 0;
seedAndPresaleTokenIssuedTotal = 0;
mainSaleTokenLocked = true;
}
function unlockMainSaleToken() public onlyOwner {
mainSaleTokenLocked = false;
}
function lockMainSaleToken() public onlyOwner {
mainSaleTokenLocked = true;
}
function unlockRewardToken(address addr) public onlyOwner {
rewardTokenLocked[addr] = false;
}
function unlockRewardTokenMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
unlockRewardToken(addrList[i]);
}
}
function lockRewardToken(address addr) public onlyOwner {
rewardTokenLocked[addr] = true;
}
function lockRewardTokenMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
lockRewardToken(addrList[i]);
}
}
// Check if a given address is locked. The address can be in the whitelist or in the reward
function isLocked(address addr) public view returns (bool) {
// Main sale is running, any addr is locked
if (mainSaleTokenLocked) {
return true;
} else {
// Main sale is ended and thus any whitelist addr is unlocked
if (isWhitelisted(addr)) {
return false;
} else {
// If the addr is in the reward, it must be checked if locked
// If the addr is not in the reward, it is considered unlocked
return rewardTokenLocked[addr];
}
}
}
function totalSupply() public view returns (uint256) {
return totalTokenIssued.add(seedAndPresaleTokenIssuedTotal).add(airDropTokenIssuedTotal).add(bountyTokenIssuedTotal);
}
function totalMainSaleTokenIssued() public view returns (uint256) {
return totalTokenIssued;
}
function totalMainSaleTokenLimit() public view returns (uint256) {
return TOKEN_SUPPLY_MAINSALE_LIMIT;
}
function totalPreSaleTokenIssued() public view returns (uint256) {
return seedAndPresaleTokenIssuedTotal;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(isLocked(msg.sender) == false);
require(isLocked(_to) == false);
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(isLocked(_from) == false);
require(isLocked(_to) == false);
return super.transferFrom(_from, _to, _amount);
}
function setIcoContract(address _icoContract) public onlyOwner {
// Allow to set the ICO contract only once
require(icoContract == address(0));
require(_icoContract != address(0));
icoContract = _icoContract;
}
function sell(address buyer, uint256 tokens) public returns (bool success) {
require (icoContract != address(0));
// The sell() method can only be called by the fixedly-set ICO contract
require (msg.sender == icoContract);
require (tokens > 0);
require (buyer != address(0));
// Only whitelisted address can buy tokens. Otherwise, refund
require (isWhitelisted(buyer));
require (totalTokenIssued.add(tokens) <= TOKEN_SUPPLY_MAINSALE_LIMIT);
// Register tokens issued to the buyer
balances[buyer] = balances[buyer].add(tokens);
// Update total amount of tokens issued
totalTokenIssued = totalTokenIssued.add(tokens);
emit Transfer(address(MAINSALE_EVENT), buyer, tokens);
return true;
}
function rewardAirdrop(address _to, uint256 _amount) public onlyOwner {
// this check also ascertains _amount is positive
require(_amount <= TOKEN_SUPPLY_AIRDROP_LIMIT);
require(airDropTokenIssuedTotal < TOKEN_SUPPLY_AIRDROP_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_AIRDROP_LIMIT.sub(airDropTokenIssuedTotal);
if (_amount > remainingTokens) {
_amount = remainingTokens;
}
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
airDropTokenIssuedTotal = airDropTokenIssuedTotal.add(_amount);
// Lock the receiver
rewardTokenLocked[_to] = true;
emit Transfer(address(AIRDROP_EVENT), _to, _amount);
}
function rewardBounty(address _to, uint256 _amount) public onlyOwner {
// this check also ascertains _amount is positive
require(_amount <= TOKEN_SUPPLY_BOUNTY_LIMIT);
require(bountyTokenIssuedTotal < TOKEN_SUPPLY_BOUNTY_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_BOUNTY_LIMIT.sub(bountyTokenIssuedTotal);
if (_amount > remainingTokens) {
_amount = remainingTokens;
}
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
bountyTokenIssuedTotal = bountyTokenIssuedTotal.add(_amount);
// Lock the receiver
rewardTokenLocked[_to] = true;
emit Transfer(address(BOUNTY_EVENT), _to, _amount);
}
function rewardBountyMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
rewardBounty(addrList[i], amountList[i]);
}
}
function rewardAirdropMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
rewardAirdrop(addrList[i], amountList[i]);
}
}
function handlePresaleToken(address _to, uint256 _amount) public onlyOwner {
require(_amount <= TOKEN_SUPPLY_SEED_PRESALE_LIMIT);
require(seedAndPresaleTokenIssuedTotal < TOKEN_SUPPLY_SEED_PRESALE_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_SEED_PRESALE_LIMIT.sub(seedAndPresaleTokenIssuedTotal);
require (_amount <= remainingTokens);
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
seedAndPresaleTokenIssuedTotal = seedAndPresaleTokenIssuedTotal.add(_amount);
emit Transfer(address(PRESALE_EVENT), _to, _amount);
// Also add to whitelist
set(_to);
}
function handlePresaleTokenMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
handlePresaleToken(addrList[i], amountList[i]);
}
}
}
| 146,402 | 13,840 |
ffc8c75df05316aa2684eff522eb90d455a2e3b5bc7f1be2e0d93796087250c0
| 11,235 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Others/0x1242B404ccaab81D1A2a5429160D91CaE749Db4c.sol
| 2,981 | 9,766 |
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 "CryptoSolarSystem.cc";
}
function symbol() public pure returns (string _symbol) {
return "CSS";
}
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);
}
| 336,441 | 13,841 |
3f8700ac647c9141d3253fe2ec0d5dd97ff98fd046535fe491fa36a94d77fd9f
| 15,038 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/95/950467016f6c0b71142ad4fd35cf0be79f2643ab_TetherToken.sol
| 2,760 | 11,198 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract TetherToken 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 TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 116,742 | 13,842 |
55466a7a2ebc601846ff8b6641c147b2e6bb8a3ec6c81597fa7efc2eef21b051
| 24,638 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/10/1063c0ffd37c20c8067b4f750dc0071da02b6f19_Aleph.sol
| 3,000 | 11,473 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// 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;
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IJoeFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IJoeRouter {
function WAVAX() external pure returns (address);
function factory() external pure returns (address);
}
interface IJoePair{
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
contract Aleph is Context, IERC20, IERC20Metadata,Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name = "Aleph Finance";
string private _symbol = "nALEPH";
uint256 private _initSupply = 200000*10**18;
uint256 public dexTaxFee = 9900; //take fee while sell token to dex - resolution *100
address public taxAddress;
address public immutable pairAddress;
address public immutable routerAddress;
mapping(address => bool) private _isExcludedFromFee;
constructor() {
_mint(msg.sender, _initSupply);
taxAddress = payable(msg.sender);
//IJoeRouter _router = IJoeRouter(0xECC5428A66808FC40A464e5B3F4D265Df985E3E8); //for test
IJoeRouter _router = IJoeRouter(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
pairAddress = IJoeFactory(_router.factory())
.createPair(address(this), _router.WAVAX());
// set the rest of the contract variables
routerAddress = address(_router);
_isExcludedFromFee[owner()] = true;
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setTaxAddress(address _taxAddress) public onlyOwner {
taxAddress = _taxAddress;
}
function setTax(uint256 _taxFee) public onlyOwner{
dexTaxFee = _taxFee;
}
function isExcludedFromFee(address account) public view returns (bool) {
return _isExcludedFromFee[account];
}
function amountForEth(uint256 ethAmount) public view returns(uint256 tokenAmount){
address _token0Address = IJoePair(pairAddress).token0();
address WAVAXAddress = IJoeRouter(routerAddress).WAVAX();
(uint112 _reserve0,uint112 _reserve1,) = IJoePair(pairAddress).getReserves();
uint256 _tokenAmount;
uint256 _WAVAXAmount;
if(_token0Address==WAVAXAddress){
_WAVAXAmount = _reserve0;
_tokenAmount = _reserve1;
}
else{
_WAVAXAmount = _reserve1;
_tokenAmount = _reserve0;
}
tokenAmount = ethAmount.mul(_tokenAmount).div(_WAVAXAmount);
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance.sub(subtractedValue));
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance.sub(amount);
}
bool takeFee = true;
if (_isExcludedFromFee[sender]) {
takeFee = false;
}
if(recipient==pairAddress&&takeFee){
uint256 taxFee = amount.mul(dexTaxFee).div(10000);
_balances[taxAddress] = _balances[taxAddress].add(taxFee);
emit Transfer(sender, taxAddress, taxFee);
amount = amount.sub(taxFee);
}
_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 _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);
}
}
| 97,707 | 13,843 |
b2893a0b08c2ebe2c1d16743f78f45e91349567d579df44d5ffd4d648b4a711c
| 25,450 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/6a/6A3083F47d56dB7BdB2783698407Cc95A0DC7a1c_TreasuryV1.sol
| 3,240 | 12,666 |
pragma solidity 0.8.5;
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// OpenZeppelin Contracts v4.4.1 (access/AccessControl.sol)
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role, address account) internal view {
if (!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 TreasuryV1 is
AccessControl {
bool private inSwap;
uint256 minimumTokenToSwap; // maximum token that able to swap at one time
uint256 fixedLimitTokenToSwap; // fixed limit token to swap
uint256 percentageToSwap; // 2 digits _00
address mainToken; // Frock Token Address
address treasuryDestination; // FTM will be sent to this address after swap
bytes32 public constant CALLER_ROLE = keccak256("CALLER");
IUniswapV2Router02 public uniswapV2Router;
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
event SwapAndSend(uint256 amountToSwap, uint256 ftmBalanceAmount, address treasuryDestination);
event Withdraw(uint256 ftmBalanceAmount, address treasuryDestination);
event WithdrawToken(uint256 amount, address destination);
event UpdateMainToken(address newMainTokenAddress);
event UpdateTreasuryDestination(address newTreasuryDestination);
event UpdateMinimumTokenToSwap(uint256 newMinimumTokenToSwap);
event UpdateFixedTokenToSwap(uint256 newFixedTokenToSwap);
event UpdatePercentageTokenToSwap(uint256 newPercentageTokenToSwap);
// Initialize
constructor(uint256 _minimumTokenToSwap,
uint256 _fixedLimitTokenToSwap,
uint256 _percentageToSwap,
address _mainToken,
address _treasuryDestination) {
// Setup deployer as Admin when construction
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
uniswapV2Router = IUniswapV2Router02(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
inSwap = false;
minimumTokenToSwap = _minimumTokenToSwap;
fixedLimitTokenToSwap = _fixedLimitTokenToSwap;
percentageToSwap = _percentageToSwap;
mainToken = _mainToken;
treasuryDestination = _treasuryDestination;
}
function swapAndSend() external onlyRole(CALLER_ROLE) {
require(mainToken != address(0), "Treasury: Main Token not setted yet");
require(treasuryDestination != address(0), "Treasury : Destination not setted yet");
require(minimumTokenToSwap > 0, "Treasury: Minimum Token to Swap not setted yet");
require(getTokenBalance() > minimumTokenToSwap, "Treasury: Not passing minimum token");
require(getTokenBalance() >= fixedLimitTokenToSwap, "Treasury: Not passing fixed limit token to swap");
uint256 percentageAmountToSwap = getTokenBalance() * percentageToSwap / 10000;
uint256 amountToSwap = percentageAmountToSwap >= fixedLimitTokenToSwap ? percentageAmountToSwap : fixedLimitTokenToSwap;
// Swap
_swapTokensForEth(amountToSwap);
uint256 ftmBalanceAmount = getBalance();
// Send FTM
_safeTransferETH(treasuryDestination, ftmBalanceAmount);
emit SwapAndSend(amountToSwap, ftmBalanceAmount, treasuryDestination);
}
function withdraw() external onlyRole(DEFAULT_ADMIN_ROLE) {
uint256 ftmBalanceAmount = getBalance();
// Send FTM
_safeTransferETH(treasuryDestination, ftmBalanceAmount);
emit Withdraw(ftmBalanceAmount, treasuryDestination);
}
function withdrawToken(address destination, uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE) {
// Send Token
require(IERC20(mainToken).transfer(destination, amount), "Treasury: Fail Transfer Token");
emit WithdrawToken(amount, destination);
}
function _swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(mainToken);
path[1] = uniswapV2Router.WETH();
IERC20(mainToken).approve(address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function getTokenBalance() public view returns(uint256 tokenAmount) {
return IERC20(mainToken).balanceOf(address(this));
}
function getBalance() public view returns(uint256 balance) {
return address(this).balance;
}
function setMainToken(address tokenAddress) external onlyRole(DEFAULT_ADMIN_ROLE) {
mainToken = tokenAddress;
emit UpdateMainToken(tokenAddress);
}
function setTreasuryDestination(address newTreasuryDestination) external onlyRole(DEFAULT_ADMIN_ROLE) {
treasuryDestination = newTreasuryDestination;
emit UpdateTreasuryDestination(newTreasuryDestination);
}
function setMinimumTokenToSwap(uint256 newMinimumTokenToSwap) external onlyRole(DEFAULT_ADMIN_ROLE) {
minimumTokenToSwap = newMinimumTokenToSwap;
emit UpdateMinimumTokenToSwap(newMinimumTokenToSwap);
}
function setFixedTokenToSwap(uint256 newFixedTokenToSwap) external onlyRole(DEFAULT_ADMIN_ROLE) {
fixedLimitTokenToSwap = newFixedTokenToSwap;
emit UpdateFixedTokenToSwap(newFixedTokenToSwap);
}
function setPercentageTokenToSwap(uint256 newPercentageTokenToSwap) external onlyRole(DEFAULT_ADMIN_ROLE) {
percentageToSwap = newPercentageTokenToSwap;
emit UpdatePercentageTokenToSwap(newPercentageTokenToSwap);
}
function _safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'Treasury: ETH_TRANSFER_FAILED');
}
// Function to receive Ether. msg.data must be empty
receive() external payable {}
// Fallback function is called when msg.data is not empty
fallback() external payable {}
}
| 327,766 | 13,844 |
2e210baf21296b25a225c6eeef8127ad5f51e670f5e38aa51c3289c1b301e083
| 15,102 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/36/36d15210379De820E55Dffdd0A2bB05079273C21_Noonercoin.sol
| 3,899 | 14,082 |
pragma solidity ^0.5.0;
contract ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occuranceOfRandonNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 totalCycleLeft = 20;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
if(now-weekStartTime > 720){ // 720 secs = 12 min // 3600
popRandomVariable();
weekStartTime=now;//given now
}
//burn the tokens before minting
if(isNewCycleStart){
uint256 randomValue = randomVariablePicker();
if(randomValue != 150){
burnToken();
isNewCycleStart = false;
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = now - startTime; //unixtime - startTime = secs
uint256 fromTime = _cycleTime - _frequency; //72576000 // 86400 - 120 = 86280
if(timeDiff > fromTime){ //120weeks - 120seconds
if(timeDiff < _cycleTime){//120 weeks
_randomValue = randomVariablePicker();
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerVaue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalVaue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occuranceOfRandonNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occuranceOfRandonNumber[__randomVariable[0]];
delete occuranceOfRandonNumber[__randomVariable[1]];
delete occuranceOfRandonNumber[__randomVariable[2]];
delete occuranceOfRandonNumber[__randomVariable[3]];
delete occuranceOfRandonNumber[__randomVariable[4]];
}
}
return true;
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occuranceOfRandonNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
// for(uint256 index=0;index<__remainingRandomVariable.length-1;index++){
// tempRemainingRandomVariable[index]= __remainingRandomVariable[index];
// }
// __remainingRandomVariable = tempRemainingRandomVariable;
}
if(occuranceOfRandonNumber[randomNumber]<24){
occuranceOfRandonNumber[randomNumber] = occuranceOfRandonNumber[randomNumber]+1;
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
uint256 signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerVaue(flag * 604800, 150 ** index, index);
uint256 intDecimalValue = getDecimalVaue(flag * 604800, 150 ** index, index);
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 iterationsInOneCycle = _cycleTime/_frequency;
uint256 totalMintedTokens = noonercoin[adminAddress]*10**18 + noonerwei[adminAddress] + totalWeiBurned +
iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
uint256 weiToBurned = 27000000*10**18 - (totalMintedTokens + signmaValueWei) - totalWeiBurned;
uint256 totalWeiInAdminAcc = noonercoin[adminAddress] * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc < weiToBurned)
return false;
uint256 remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = remainingWei/10**18;
noonerwei[adminAddress] = remainingWei - noonercoin[adminAddress] * 10**18;
totalWeiBurned = totalWeiBurned + weiToBurned;
return true;
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) internal view returns (uint256){
return noonerwei[add];
}
function getIntegerVaue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalVaue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
uint256 randomValue = randomVariablePicker();
if(randomValue != 150){
if(isNewCycleStart){
burnToken();
isNewCycleStart = false;
}
}
uint256 weiAfterMint = noonerwei[add] + missedWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
noonercoin[add] = noonercoin[add] + missedToken + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
return true;
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
uint256 randomValue = randomVariablePicker();
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerVaue(flag, randomValue, 1);
mintingRateNoonerWei = getDecimalVaue(flag, randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occuranceOfRandonNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occuranceOfRandonNumber[__randomVariable[0]];
delete occuranceOfRandonNumber[__randomVariable[1]];
delete occuranceOfRandonNumber[__randomVariable[2]];
delete occuranceOfRandonNumber[__randomVariable[3]];
delete occuranceOfRandonNumber[__randomVariable[4]];
return true;
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
return lastMintingTimeAndStartTimeDifference;
}
function getCurrentTimeAndStartTimeDifference() public view returns (uint256) {
uint256 currentTimeAndStartTimeDifference = now - startTime;
return currentTimeAndStartTimeDifference;
}
function checkFailedTransactions(address add) public view returns (uint256) {
uint256 adminBalance = noonercoin[add]; //admin balance
uint256 currMintingRate = getLastMintingRate();
uint256 timeDifference = lastMintingTime - startTime; //checking time from start time to current time and changing to hrs format.
uint256 valueForEach = timeDifference/_frequency; // we will get 1,2,3....
uint256 estimatedMintedToken = _fundersAmount + valueForEach * currMintingRate;// gets the total coins for that total hours
uint256 checkDifference = estimatedMintedToken - adminBalance;// checking diff from the estimate total and also from admin bal
uint256 missedTokens = checkDifference / mintingRateNoonerCoin; //finding missing tokens.
return missedTokens;
}
function checkMissingTokens(address add) public view returns (uint256, uint256) {
uint256 adminBalance = noonercoin[add]; //admin bal
uint256 adminBalanceinWei = noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0);
}
if (lastMintingTime != 0) {
uint256 timeDifference = lastMintingTime - startTime; //checking time from start time to current time and changing to hrs format.
uint256 valueForEach = timeDifference/_frequency; // we will get 1,2,3....
uint256 estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;// gets the total coins for that total hours
uint256 estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedTokenWei -= temp;
estimatedMintedToken += temp;
uint256 checkDifferenceWei = estimatedMintedTokenWei - (adminBalanceinWei);// checking diff from the estimate total and also from admin bal
uint256 checkDifference = estimatedMintedToken - adminBalance;
return (checkDifference, checkDifferenceWei);
}
}
function currentMintRate() public view returns (uint256){
uint256 currMintingRate = getLastMintingRate();
return currMintingRate;
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory, uint256) {
return (_randomValue, __remainingRandomVariable,randomNumber);
}
function occurancesOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occuranceOfRandonNumber[__randomVariable[0]],occuranceOfRandonNumber[__randomVariable[1]],occuranceOfRandonNumber[__randomVariable[2]],occuranceOfRandonNumber[__randomVariable[3]], occuranceOfRandonNumber[__randomVariable[4]]);
}
function occurancesOfPreferedRandomNumber(uint256 number) public view returns(uint256){
return occuranceOfRandonNumber[number];
}
}
| 99,496 | 13,845 |
40addcbbd60ff562018238379f9e653fc759b195e948493d3b84e61a01168cb2
| 33,271 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d6/d6873bcf2abf5b69d5f65d6361a20e4c21f3ec3e_Identity.sol
| 3,869 | 15,192 |
// Sources flattened with hardhat v2.12.6 https://hardhat.org
// File contracts/interface/IERC734.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.17;
interface IERC734 {
event Approved(uint256 indexed executionId, bool approved);
event Executed(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
event ExecutionRequested(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
event ExecutionFailed(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
event KeyAdded(bytes32 indexed key, uint256 indexed purpose, uint256 indexed keyType);
event KeyRemoved(bytes32 indexed key, uint256 indexed purpose, uint256 indexed keyType);
function addKey(bytes32 _key, uint256 _purpose, uint256 _keyType) external returns (bool success);
function approve(uint256 _id, bool _approve) external returns (bool success);
function removeKey(bytes32 _key, uint256 _purpose) external returns (bool success);
function execute(address _to, uint256 _value, bytes calldata _data) external payable returns (uint256 executionId);
function getKey(bytes32 _key) external view returns (uint256[] memory purposes, uint256 keyType, bytes32 key);
function getKeyPurposes(bytes32 _key) external view returns(uint256[] memory _purposes);
function getKeysByPurpose(uint256 _purpose) external view returns (bytes32[] memory keys);
function keyHasPurpose(bytes32 _key, uint256 _purpose) external view returns (bool exists);
}
// File contracts/interface/IERC735.sol
interface IERC735 {
event ClaimAdded(bytes32 indexed claimId,
uint256 indexed topic,
uint256 scheme,
address indexed issuer,
bytes signature,
bytes data,
string uri);
event ClaimRemoved(bytes32 indexed claimId,
uint256 indexed topic,
uint256 scheme,
address indexed issuer,
bytes signature,
bytes data,
string uri);
event ClaimChanged(bytes32 indexed claimId,
uint256 indexed topic,
uint256 scheme,
address indexed issuer,
bytes signature,
bytes data,
string uri);
function addClaim(uint256 _topic,
uint256 _scheme,
address issuer,
bytes calldata _signature,
bytes calldata _data,
string calldata _uri)
external returns (bytes32 claimRequestId);
function removeClaim(bytes32 _claimId) external returns (bool success);
function getClaim(bytes32 _claimId)
external view returns(uint256 topic,
uint256 scheme,
address issuer,
bytes memory signature,
bytes memory data,
string memory uri);
function getClaimIdsByTopic(uint256 _topic) external view returns(bytes32[] memory claimIds);
}
// File contracts/interface/IIdentity.sol
// solhint-disable-next-line no-empty-blocks
interface IIdentity is IERC734, IERC735 {}
// File contracts/interface/IClaimIssuer.sol
interface IClaimIssuer is IIdentity {
event ClaimRevoked(bytes indexed signature);
function revokeClaim(bytes32 _claimId, address _identity) external returns(bool);
function revokeClaimBySignature(bytes calldata signature) external;
function isClaimRevoked(bytes calldata _sig) external view returns (bool);
function isClaimValid(IIdentity _identity,
uint256 claimTopic,
bytes calldata sig,
bytes calldata data)
external view returns (bool);
function getRecoveredAddress(bytes calldata sig, bytes32 dataHash) external pure returns (address);
}
// File contracts/storage/Structs.sol
contract Structs {
struct Key {
uint256[] purposes;
uint256 keyType;
bytes32 key;
}
struct Execution {
address to;
uint256 value;
bytes data;
bool approved;
bool executed;
}
struct Claim {
uint256 topic;
uint256 scheme;
address issuer;
bytes signature;
bytes data;
string uri;
}
}
// File contracts/storage/Storage.sol
contract Storage is Structs {
// nonce used by the execute/approve function
uint256 internal _executionNonce;
// keys as defined by IERC734
mapping(bytes32 => Key) internal _keys;
// keys for a given purpose
// purpose 1 = MANAGEMENT
// purpose 2 = ACTION
// purpose 3 = CLAIM
mapping(uint256 => bytes32[]) internal _keysByPurpose;
// execution data
mapping(uint256 => Execution) internal _executions;
// claims held by the ONCHAINID
mapping(bytes32 => Claim) internal _claims;
// array of claims for a given topic
mapping(uint256 => bytes32[]) internal _claimsByTopic;
// status on initialization
bool internal _initialized = false;
// status on potential interactions with the contract
bool internal _canInteract = false;
uint256[49] private __gap;
}
// File contracts/version/Version.sol
contract Version {
function version() external pure returns (string memory) {
// version 2.0.0
return "2.0.0";
}
}
// File contracts/Identity.sol
contract Identity is Storage, IIdentity, Version {
modifier delegatedOnly() {
require(_canInteract == true, "Interacting with the library contract is forbidden.");
_;
}
modifier onlyManager() {
require(msg.sender == address(this) || keyHasPurpose(keccak256(abi.encode(msg.sender)), 1)
, "Permissions: Sender does not have management key");
_;
}
modifier onlyClaimKey() {
require(msg.sender == address(this) || keyHasPurpose(keccak256(abi.encode(msg.sender)), 3)
, "Permissions: Sender does not have claim signer key");
_;
}
constructor(address initialManagementKey, bool _isLibrary) {
require(initialManagementKey != address(0), "invalid argument - zero address");
if (!_isLibrary) {
__Identity_init(initialManagementKey);
} else {
_initialized = true;
}
}
function initialize(address initialManagementKey) external {
require(initialManagementKey != address(0), "invalid argument - zero address");
__Identity_init(initialManagementKey);
}
function execute(address _to, uint256 _value, bytes memory _data)
external
delegatedOnly
override
payable
returns (uint256 executionId)
{
uint256 _executionId = _executionNonce;
_executions[_executionId].to = _to;
_executions[_executionId].value = _value;
_executions[_executionId].data = _data;
_executionNonce++;
emit ExecutionRequested(_executionId, _to, _value, _data);
if (keyHasPurpose(keccak256(abi.encode(msg.sender)), 1)) {
approve(_executionId, true);
}
else if (_to != address(this) && keyHasPurpose(keccak256(abi.encode(msg.sender)), 2)){
approve(_executionId, true);
}
return _executionId;
}
function getKey(bytes32 _key)
external
override
view
returns(uint256[] memory purposes, uint256 keyType, bytes32 key)
{
return (_keys[_key].purposes, _keys[_key].keyType, _keys[_key].key);
}
function getKeyPurposes(bytes32 _key)
external
override
view
returns(uint256[] memory _purposes)
{
return (_keys[_key].purposes);
}
function getKeysByPurpose(uint256 _purpose)
external
override
view
returns(bytes32[] memory keys)
{
return _keysByPurpose[_purpose];
}
function getClaimIdsByTopic(uint256 _topic)
external
override
view
returns(bytes32[] memory claimIds)
{
return _claimsByTopic[_topic];
}
function addKey(bytes32 _key, uint256 _purpose, uint256 _type)
public
delegatedOnly
onlyManager
override
returns (bool success)
{
if (_keys[_key].key == _key) {
uint256[] memory _purposes = _keys[_key].purposes;
for (uint keyPurposeIndex = 0; keyPurposeIndex < _purposes.length; keyPurposeIndex++) {
uint256 purpose = _purposes[keyPurposeIndex];
if (purpose == _purpose) {
revert("Conflict: Key already has purpose");
}
}
_keys[_key].purposes.push(_purpose);
} else {
_keys[_key].key = _key;
_keys[_key].purposes = [_purpose];
_keys[_key].keyType = _type;
}
_keysByPurpose[_purpose].push(_key);
emit KeyAdded(_key, _purpose, _type);
return true;
}
function approve(uint256 _id, bool _approve)
public
delegatedOnly
override
returns (bool success)
{
require(_id < _executionNonce, "Cannot approve a non-existing execution");
require(!_executions[_id].executed, "Request already executed");
if(_executions[_id].to == address(this)) {
require(keyHasPurpose(keccak256(abi.encode(msg.sender)), 1), "Sender does not have management key");
}
else {
require(keyHasPurpose(keccak256(abi.encode(msg.sender)), 2), "Sender does not have action key");
}
emit Approved(_id, _approve);
if (_approve == true) {
_executions[_id].approved = true;
// solhint-disable-next-line avoid-low-level-calls
(success,) = _executions[_id].to.call{value:(_executions[_id].value)}(_executions[_id].data);
if (success) {
_executions[_id].executed = true;
emit Executed(_id,
_executions[_id].to,
_executions[_id].value,
_executions[_id].data);
return true;
} else {
emit ExecutionFailed(_id,
_executions[_id].to,
_executions[_id].value,
_executions[_id].data);
return false;
}
} else {
_executions[_id].approved = false;
}
return false;
}
function removeKey(bytes32 _key, uint256 _purpose)
public
delegatedOnly
onlyManager
override
returns (bool success)
{
require(_keys[_key].key == _key, "NonExisting: Key isn't registered");
uint256[] memory _purposes = _keys[_key].purposes;
uint purposeIndex = 0;
while (_purposes[purposeIndex] != _purpose) {
purposeIndex++;
if (purposeIndex == _purposes.length) {
revert("NonExisting: Key doesn't have such purpose");
}
}
_purposes[purposeIndex] = _purposes[_purposes.length - 1];
_keys[_key].purposes = _purposes;
_keys[_key].purposes.pop();
uint keyIndex = 0;
uint arrayLength = _keysByPurpose[_purpose].length;
while (_keysByPurpose[_purpose][keyIndex] != _key) {
keyIndex++;
if (keyIndex >= arrayLength) {
break;
}
}
_keysByPurpose[_purpose][keyIndex] = _keysByPurpose[_purpose][arrayLength - 1];
_keysByPurpose[_purpose].pop();
uint keyType = _keys[_key].keyType;
if (_purposes.length - 1 == 0) {
delete _keys[_key];
}
emit KeyRemoved(_key, _purpose, keyType);
return true;
}
function addClaim(uint256 _topic,
uint256 _scheme,
address _issuer,
bytes memory _signature,
bytes memory _data,
string memory _uri)
public
delegatedOnly
onlyClaimKey
override
returns (bytes32 claimRequestId)
{
if (_issuer != address(this)) {
require(IClaimIssuer(_issuer).isClaimValid(IIdentity(address(this)), _topic, _signature, _data), "invalid claim");
}
bytes32 claimId = keccak256(abi.encode(_issuer, _topic));
_claims[claimId].topic = _topic;
_claims[claimId].scheme = _scheme;
_claims[claimId].signature = _signature;
_claims[claimId].data = _data;
_claims[claimId].uri = _uri;
if (_claims[claimId].issuer != _issuer) {
_claimsByTopic[_topic].push(claimId);
_claims[claimId].issuer = _issuer;
emit ClaimAdded(claimId, _topic, _scheme, _issuer, _signature, _data, _uri);
}
else {
emit ClaimChanged(claimId, _topic, _scheme, _issuer, _signature, _data, _uri);
}
return claimId;
}
function removeClaim(bytes32 _claimId)
public
delegatedOnly
onlyClaimKey
override
returns
(bool success) {
uint256 _topic = _claims[_claimId].topic;
if (_topic == 0) {
revert("NonExisting: There is no claim with this ID");
}
uint claimIndex = 0;
uint arrayLength = _claimsByTopic[_topic].length;
while (_claimsByTopic[_topic][claimIndex] != _claimId) {
claimIndex++;
if (claimIndex >= arrayLength) {
break;
}
}
_claimsByTopic[_topic][claimIndex] =
_claimsByTopic[_topic][arrayLength - 1];
_claimsByTopic[_topic].pop();
emit ClaimRemoved(_claimId,
_topic,
_claims[_claimId].scheme,
_claims[_claimId].issuer,
_claims[_claimId].signature,
_claims[_claimId].data,
_claims[_claimId].uri);
delete _claims[_claimId];
return true;
}
function getClaim(bytes32 _claimId)
public
override
view
returns(uint256 topic,
uint256 scheme,
address issuer,
bytes memory signature,
bytes memory data,
string memory uri)
{
return (_claims[_claimId].topic,
_claims[_claimId].scheme,
_claims[_claimId].issuer,
_claims[_claimId].signature,
_claims[_claimId].data,
_claims[_claimId].uri);
}
function keyHasPurpose(bytes32 _key, uint256 _purpose)
public
override
view
returns(bool result)
{
Key memory key = _keys[_key];
if (key.key == 0) return false;
for (uint keyPurposeIndex = 0; keyPurposeIndex < key.purposes.length; keyPurposeIndex++) {
uint256 purpose = key.purposes[keyPurposeIndex];
if (purpose == 1 || purpose == _purpose) return true;
}
return false;
}
// solhint-disable-next-line func-name-mixedcase
function __Identity_init(address initialManagementKey) internal {
require(!_initialized || _isConstructor(), "Initial key was already setup.");
_initialized = true;
_canInteract = true;
bytes32 _key = keccak256(abi.encode(initialManagementKey));
_keys[_key].key = _key;
_keys[_key].purposes = [1];
_keys[_key].keyType = 1;
_keysByPurpose[1].push(_key);
emit KeyAdded(_key, 1, 1);
}
function _isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
// solhint-disable-next-line no-inline-assembly
assembly { cs := extcodesize(self) }
return cs == 0;
}
}
| 85,177 | 13,846 |
54422a9552ad1164bb93ce786070110e8e0a51a128f4b67af260c19fa5977fd6
| 22,561 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/DfxMerkleDistributor-0x17cc38c61a8f5f68fc9619447a80f9edc019fadd.sol
| 3,752 | 13,918 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.11;
contract Ownable {
address payable public owner;
address payable internal newOwnerCandidate;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner, "Permission denied");
_;
}
function changeOwner(address payable newOwner) public onlyOwner {
newOwnerCandidate = newOwner;
}
function acceptOwner() public {
require(msg.sender == newOwnerCandidate, "Permission denied");
owner = newOwnerCandidate;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
interface IToken {
function decimals() external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function balanceOf(address account) external view returns (uint);
function approve(address spender, uint value) external;
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function deposit() external payable;
function mint(address, uint256) external;
function withdraw(uint amount) external;
function totalSupply() view external returns (uint256);
function burnFrom(address account, uint256 amount) external;
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IToken token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IToken token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IToken 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(IToken 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(IToken token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IToken token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library UniversalERC20 {
using SafeMath for uint256;
using SafeERC20 for IToken;
IToken private constant ZERO_ADDRESS = IToken(0x0000000000000000000000000000000000000000);
IToken private constant ETH_ADDRESS = IToken(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
function universalTransfer(IToken token, address to, uint256 amount) internal {
universalTransfer(token, to, amount, false);
}
function universalTransfer(IToken token, address to, uint256 amount, bool mayFail) internal returns(bool) {
if (amount == 0) {
return true;
}
if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
if (mayFail) {
return address(uint160(to)).send(amount);
} else {
address(uint160(to)).transfer(amount);
return true;
}
} else {
token.safeTransfer(to, amount);
return true;
}
}
function universalApprove(IToken token, address to, uint256 amount) internal {
if (token != ZERO_ADDRESS && token != ETH_ADDRESS) {
token.safeApprove(to, amount);
}
}
function universalTransferFrom(IToken token, address from, address to, uint256 amount) internal {
if (amount == 0) {
return;
}
if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
require(from == msg.sender && msg.value >= amount, "msg.value is zero");
if (to != address(this)) {
address(uint160(to)).transfer(amount);
}
if (msg.value > amount) {
msg.sender.transfer(uint256(msg.value).sub(amount));
}
} else {
token.safeTransferFrom(from, to, amount);
}
}
function universalBalanceOf(IToken token, address who) internal view returns (uint256) {
if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
return who.balance;
} else {
return token.balanceOf(who);
}
}
}
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 MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
// Hash(current element of the proof + current computed hash)
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
// Check if the computed hash (root) is equal to the provided root
return computedHash == root;
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y, uint base) internal pure returns (uint z) {
z = add(mul(x, y), base / 2) / base;
}
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
}
contract DfxMerkleDistributor is Ownable, DSMath {
using UniversalERC20 for IToken;
address public immutable token;
bytes32 public immutable merkleRoot;
bool public finalized;
// This is a packed array of booleans.
mapping(uint256 => uint256) internal claimedBitMap;
// This event is triggered whenever a call to #claim succeeds.
event Claimed(uint256 index, address account, uint256 amount);
constructor(address token_, bytes32 merkleRoot_) public {
token = token_;
merkleRoot = merkleRoot_;
}
// ** PUBLIC VIEW functions **
function isClaimed(uint256 index) public view returns (bool) {
uint256 claimedWordIndex = index / 256;
uint256 claimedBitIndex = index % 256;
uint256 claimedWord = claimedBitMap[claimedWordIndex];
uint256 mask = (1 << claimedBitIndex);
return claimedWord & mask == mask;
}
// ** PUBLIC functions **
// Check distribution algorithm here https://github.com/DeFireX/dfx-merkle-distributor
function claim(uint256 index, address account, uint256 amount, bytes32[] memory merkleProof) public {
require(!isClaimed(index), 'MerkleDistributor: Already claimed.');
// Verify the merkle proof.
bytes32 node = keccak256(abi.encodePacked(index, account, amount));
require(MerkleProof.verify(merkleProof, merkleRoot, node), 'MerkleDistributor: Invalid proof.');
// Mark it claimed.
_setClaimed(index);
IToken(token).transfer(account, amount);
emit Claimed(index, account, amount);
}
// ** OWNER functions **
function withdrawTokensGetStuck(address _tokenAddress, uint256 _amount, address _toAddress) public onlyOwner {
if (finalized) require(_tokenAddress != token, 'Cant withdraw DFX tokens');
IToken(_tokenAddress).universalTransfer(_toAddress, _amount);
}
function finalize() public onlyOwner {
finalized = true;
}
// ** INTERNAL functions **
function _setClaimed(uint256 index) internal {
uint256 claimedWordIndex = index / 256;
uint256 claimedBitIndex = index % 256;
claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);
}
receive() external payable {
require(false);
}
}
| 176,719 | 13,847 |
ef8ec261618c1f531ca059648a0b4cf7460800c4c77bb58e19a7df70e22df80e
| 36,390 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/2a/2abebef053ec6417ca06e16c31f1e9e6ea312caa_Feature.sol
| 5,266 | 21,340 |
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint[50] private ______gap;
}
contract EIP712Base is Initializable {
struct EIP712Domain {
string name;
string version;
address verifyingContract;
bytes32 salt;
}
bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(bytes("EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"));
bytes32 internal domainSeperator;
// supposed to be called once while initializing.
// one of the contractsa that inherits this contract follows proxy pattern
// so it is not possible to do this in a constructor
function _initializeEIP712(string memory name,
string memory version)
internal
initializer
{
_setDomainSeperator(name, version);
}
function _setDomainSeperator(string memory name, string memory version) internal {
domainSeperator = keccak256(abi.encode(EIP712_DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes(version)),
address(this),
bytes32(getChainId())));
}
function getDomainSeperator() public view returns (bytes32) {
return domainSeperator;
}
function getChainId() public view returns (uint) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
function toTypedMessageHash(bytes32 messageHash)
internal
view
returns (bytes32)
{
return
keccak256(abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash));
}
}
contract NativeMetaTransaction is EIP712Base {
bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(bytes("MetaTransaction(uint256 nonce,address from,bytes functionSignature)"));
event MetaTransactionExecuted(address userAddress,
address relayerAddress,
bytes functionSignature);
mapping(address => uint) nonces;
struct MetaTransaction {
uint256 nonce;
address from;
bytes functionSignature;
}
function executeMetaTransaction(address userAddress,
bytes memory functionSignature,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) public payable returns (bytes memory) {
MetaTransaction memory metaTx = MetaTransaction({
nonce: nonces[userAddress],
from: userAddress,
functionSignature: functionSignature
});
require(verify(userAddress, metaTx, sigR, sigS, sigV),
"Signer and signature do not match");
// increase nonce for user (to avoid re-use)
uint256 noncesByUser = nonces[userAddress];
require(noncesByUser + 1 >= noncesByUser, "Must be not an overflow");
nonces[userAddress] = noncesByUser + 1;
emit MetaTransactionExecuted(userAddress,
msg.sender,
functionSignature);
// Append userAddress and relayer address at the end to extract it from calling context
(bool success, bytes memory returnData) = address(this).call(abi.encodePacked(functionSignature, userAddress));
require(success, "Function call not successful");
return returnData;
}
function hashMetaTransaction(MetaTransaction memory metaTx)
internal
pure
returns (bytes32)
{
return
keccak256(abi.encode(META_TRANSACTION_TYPEHASH,
metaTx.nonce,
metaTx.from,
keccak256(metaTx.functionSignature)));
}
function getNonce(address user) public view returns (uint256 nonce) {
nonce = nonces[user];
}
function verify(address signer,
MetaTransaction memory metaTx,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) internal view returns (bool) {
require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
return
signer ==
ecrecover(toTypedMessageHash(hashMetaTransaction(metaTx)),
sigV,
sigR,
sigS);
}
}
contract ChainConstants {
string constant public ERC712_VERSION = "1";
uint256 constant public ROOT_CHAIN_ID = 1;
bytes constant public ROOT_CHAIN_ID_BYTES = hex"01";
uint256 constant public CHILD_CHAIN_ID = 42161;
bytes constant public CHILD_CHAIN_ID_BYTES = hex"a4b1";
}
abstract contract ContextMixin {
function msgSender()
internal
view
returns (address sender)
{
if (msg.sender == address(this)) {
bytes memory array = msg.data;
uint256 index = msg.data.length;
assembly {
// Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
sender := and(mload(add(array, index)),
0xffffffffffffffffffffffffffffffffffffffff)
}
} else {
sender = msg.sender;
}
return sender;
}
}
interface IArbitrable {
event MetaEvidence(uint256 indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint256 indexed _disputeID, uint256 _metaEvidenceID, uint256 _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator, uint256 indexed _evidenceGroupID, address indexed _party, string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint256 indexed _disputeID, uint256 _ruling);
function rule(uint256 _disputeID, uint256 _ruling) external;
}
abstract contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData; // Extra data to require particular dispute and appeal behaviour.
modifier onlyArbitrator {require(msg.sender == address(arbitrator), "Can only be called by the arbitrator."); _;}
constructor(Arbitrator _arbitrator, bytes storage _arbitratorExtraData) {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint256 _disputeID, uint256 _ruling) external override onlyArbitrator {
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(_disputeID, _ruling);
}
function executeRuling(uint256 _disputeID, uint256 _ruling) virtual internal;
}
abstract contract Arbitrator {
enum DisputeStatus {Waiting, Appealable, Solved}
modifier requireArbitrationFee(bytes calldata _extraData) {
require(msg.value >= arbitrationCost(_extraData), "Not enough ETH to cover arbitration costs.");
_;
}
modifier requireAppealFee(uint256 _disputeID, bytes calldata _extraData) {
require(msg.value >= appealCost(_disputeID, _extraData), "Not enough ETH to cover appeal costs.");
_;
}
event DisputeCreation(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealPossible(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealDecision(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
function createDispute(uint256 _choices, bytes calldata _extraData) public requireArbitrationFee(_extraData) payable returns(uint256 disputeID) {}
function arbitrationCost(bytes calldata _extraData) public view virtual returns(uint256 fee);
function appeal(uint256 _disputeID, bytes calldata _extraData) public requireAppealFee(_disputeID,_extraData) payable {
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint256 _disputeID, bytes calldata _extraData) public view virtual returns(uint256 fee);
function appealPeriod(uint256 _disputeID) public view virtual returns(uint256 start, uint256 end) {}
function disputeStatus(uint256 _disputeID) public view virtual returns(DisputeStatus status);
function currentRuling(uint256 _disputeID) public view virtual returns(uint256 ruling);
}
contract Feature is Initializable, NativeMetaTransaction, ChainConstants, ContextMixin, IArbitrable {
// **************************** //
// * Contract variables * //
// **************************** //
// Amount of choices to solve the dispute if needed.
uint8 constant AMOUNT_OF_CHOICES = 2;
// Enum relative to different periods in the case of a negotiation or dispute.
enum Status { WaitingForChallenger, DisputeCreated, Resolved }
// The different parties of the dispute.
enum Party { Receiver, Challenger }
// The different ruling for the dispute resolution.
enum RulingOptions { NoRuling, ReceiverWins, ChallengerWins }
struct Transaction {
address sender;
Arbitrator arbitrator; // The arbitrator of the contract.
bytes arbitratorExtraData; // Extra data for the arbitrator.
uint256 amount; // Amount of the reward in Wei.
uint256 deposit; // Amount of the deposit in Wei.
uint256 timeoutPayment; // Time in seconds after which the transaction can be executed if not disputed.
uint256 delayClaim; // Time of the challenge period.
string metaEvidence; // Link to the meta-evidence.
uint256 runningClaimCount; // Count of running claims.
bool isExecuted;
}
struct Claim {
uint256 transactionID; // Relation one-to-one with the transaction.
address receiver; // Address of the receiver.
address challenger; // Address of the challenger.
uint256 timeoutClaim; // Time of the outdated challenge period.
uint256 lastInteraction; // Last interaction for the dispute procedure.
uint256 receiverFee; // Total fees paid by the receiver.
uint256 challengerFee; // Total fees paid by the challenge.
uint256 disputeID; // If dispute exists, the ID of the dispute.
Status status; // Status of the the dispute.
}
Transaction[] public transactions;
Claim[] public claims;
mapping (uint256 => uint) public disputeIDtoClaimID; // One-to-one relationship between the dispute and the claim.
// **************************** //
// * Events * //
// **************************** //
event Payment(uint256 indexed _transactionID, uint256 _amount, address _receiver);
event Refund(uint256 indexed _transactionID, uint256 _amount, address _party);
event ClaimSubmit(uint256 indexed _transactionID, uint256 _claimID, address _receiver);
event HasToPayFee(uint256 indexed _transactionID, Party _party);
// **************************** //
// * Contract functions * //
// * Modifying the state * //
// **************************** //
function initialize() public initializer {
_initializeEIP712("Feature", ERC712_VERSION);
}
// This is to support Native meta transactions
// never use msg.sender directly, use _msgSender() instead
function _msgSender()
internal
view
returns (address sender)
{
return ContextMixin.msgSender();
}
function createTransaction(Arbitrator _arbitrator,
bytes memory _arbitratorExtraData,
uint256 _deposit,
uint256 _timeoutPayment,
uint256 _delayClaim,
string memory _metaEvidence) public payable returns (uint256 transactionID) {
transactions.push(Transaction({
sender: _msgSender(),
arbitrator: _arbitrator,
arbitratorExtraData: _arbitratorExtraData,
amount: msg.value, // Put the amount of the transaction to the smart vault.
deposit: _deposit,
timeoutPayment: _timeoutPayment + block.timestamp,
delayClaim: _delayClaim,
metaEvidence: _metaEvidence,
runningClaimCount: 0,
isExecuted: false
}));
// Store the meta-evidence.
emit MetaEvidence(transactions.length - 1, _metaEvidence);
return transactions.length - 1;
}
function claim(uint256 _transactionID) public payable returns (uint256 claimID) {
return _claimFor(_transactionID, _msgSender());
}
function claimFor(uint256 _transactionID,
address _receiver) public payable returns (uint256 claimID) {
return _claimFor(_transactionID, _receiver);
}
function _claimFor(uint256 _transactionID,
address _receiver) internal returns (uint256 claimID) {
Transaction storage transaction = transactions[_transactionID];
uint256 arbitrationCost = transaction.arbitrator.arbitrationCost(transaction.arbitratorExtraData);
require(msg.value >= transaction.deposit + arbitrationCost, "The challenger fee must cover the deposit and the arbitration costs.");
claims.push(Claim({
transactionID: _transactionID,
receiver: _receiver,
challenger: address(0),
timeoutClaim: transaction.delayClaim + block.timestamp,
lastInteraction: block.timestamp,
receiverFee: arbitrationCost,
challengerFee: 0,
disputeID: 0,
status: Status.WaitingForChallenger
}));
claimID = claims.length - 1;
transaction.runningClaimCount++;
emit ClaimSubmit(_transactionID, claimID, _receiver);
return claimID;
}
function pay(uint256 _claimID) public {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(transaction.isExecuted == false, "The transaction should not be executed.");
require(claim.timeoutClaim <= block.timestamp, "The timeout claim should be passed.");
require(claim.status == Status.WaitingForChallenger, "The transaction shouldn't be disputed.");
transaction.isExecuted = true;
claim.status = Status.Resolved;
payable(claim.receiver).transfer(transaction.amount + transaction.deposit + claim.receiverFee);
emit Payment(claim.transactionID, transaction.amount, claim.receiver);
}
function refund(uint256 _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.isExecuted == false, "The transaction should not be refunded.");
require(transaction.timeoutPayment <= block.timestamp, "The timeout payment should be passed.");
require(transaction.runningClaimCount == 0, "The transaction should not to have running claims.");
transaction.isExecuted = true;
payable(transaction.sender).transfer(transaction.amount);
emit Refund(_transactionID, transaction.amount, transaction.sender);
}
function challengeClaim(uint256 _claimID) public payable {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
uint256 arbitrationCost = transaction.arbitrator.arbitrationCost(transaction.arbitratorExtraData);
require(claim.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.value >= transaction.deposit + arbitrationCost, "The challenger fee must cover the deposit and the arbitration costs.");
claim.challengerFee = arbitrationCost;
claim.challenger = _msgSender();
raiseDispute(_claimID, arbitrationCost);
}
function raiseDispute(uint256 _claimID, uint256 _arbitrationCost) internal {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
claim.status = Status.DisputeCreated;
claim.disputeID = transaction.arbitrator.createDispute{value: _arbitrationCost}(AMOUNT_OF_CHOICES, transaction.arbitratorExtraData);
disputeIDtoClaimID[claim.disputeID] = _claimID;
emit Dispute(transaction.arbitrator, claim.disputeID, _claimID, _claimID);
// Refund receiver if it overpaid.
if (claim.receiverFee > _arbitrationCost) {
uint256 extraFeeSender = claim.receiverFee - _arbitrationCost;
claim.receiverFee = _arbitrationCost;
payable(claim.receiver).send(extraFeeSender);
}
// Refund challenger if it overpaid.
if (claim.challengerFee > _arbitrationCost) {
uint256 extraFeeChallenger = claim.challengerFee - _arbitrationCost;
claim.challengerFee = _arbitrationCost;
payable(claim.challenger).send(extraFeeChallenger);
}
}
function submitEvidence(uint256 _claimID, string memory _evidence) public {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(claim.status < Status.Resolved,
"Must not send evidence if the dispute is resolved.");
emit Evidence(transaction.arbitrator, _claimID, _msgSender(), _evidence);
}
function appeal(uint256 _claimID) public payable {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
transaction.arbitrator.appeal{value: msg.value}(claim.disputeID, transaction.arbitratorExtraData);
}
function rule(uint256 _disputeID, uint256 _ruling) override external {
uint256 claimID = disputeIDtoClaimID[_disputeID];
Claim storage claim = claims[claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(msg.sender == address(transaction.arbitrator), "The caller must be the arbitrator.");
require(claim.status == Status.DisputeCreated, "The dispute has already been resolved.");
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(claimID, _ruling);
}
function executeRuling(uint256 _claimID, uint256 _ruling) internal {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(_ruling <= AMOUNT_OF_CHOICES, "Must be a valid ruling.");
// Give the arbitration fee back.
// Note: we use send to prevent a party from blocking the execution.
if (_ruling == uint(RulingOptions.ReceiverWins)) {
payable(claim.receiver).send(transaction.deposit);
claim.status = Status.WaitingForChallenger;
} else if (_ruling == uint(RulingOptions.ChallengerWins)) {
payable(claim.challenger).send(claim.challengerFee + transaction.deposit * 2);
claim.status = Status.Resolved;
} else {
payable(claim.challenger).send(claim.challengerFee + transaction.deposit);
claim.status = Status.WaitingForChallenger;
}
transaction.runningClaimCount--;
}
// **************************** //
// * Constant getters * //
// **************************** //
function getCountTransactions() public view returns (uint256 countTransactions) {
return transactions.length;
}
function getTransactionIDsByAddress(address _address) public view returns (uint[] memory transactionIDs) {
uint256 count = 0;
for (uint256 i = 0; i < transactions.length; i++) {
if (transactions[i].sender == _address)
count++;
}
transactionIDs = new uint[](count);
count = 0;
for (uint256 j = 0; j < transactions.length; j++) {
if (transactions[j].sender == _address)
transactionIDs[count++] = j;
}
}
function getClaimIDsByAddress(address _address) public view returns (uint[] memory claimIDs) {
uint256 count = 0;
for (uint256 i = 0; i < claims.length; i++) {
if (claims[i].receiver == _address)
count++;
}
claimIDs = new uint[](count);
count = 0;
for (uint256 j = 0; j < claims.length; j++) {
if (claims[j].receiver == _address)
claimIDs[count++] = j;
}
}
}
| 30,577 | 13,848 |
c43d4f53dac7f154bce6976bda4ec922b22b0371878dac4e8451147b0c701680
| 18,775 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x17f8afb63dfcdcc90ebe6e84f060cc306a98257d.sol
| 3,702 | 12,699 |
pragma solidity 0.4.19;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
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 CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint256 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
}
contract NebulaToken is CappedToken{
using SafeMath for uint256;
string public constant name = "Nebula AI Token";
string public constant symbol = "NBAI";
uint8 public constant decimals = 18;
bool public pvt_plmt_set;
uint256 public pvt_plmt_max_in_Wei;
uint256 public pvt_plmt_remaining_in_Wei;
uint256 public pvt_plmt_token_generated;
TokenVesting public foundation_vesting_contract;
uint256 public token_unlock_time = 1524887999; //April 27th 2018 23:59:59 GMT-4:00, 7 days after completion
mapping(address => TokenTimelock[]) public time_locked_reclaim_addresses;
//vesting starts on April 21th 2018 00:00 GMT-4:00
//vesting duration is 3 years
function NebulaToken() CappedToken(6700000000 * 1 ether) public{
uint256 foundation_held = cap.mul(55).div(100);//55% fixed for early investors, partners, nebula internal and foundation
address foundation_beneficiary_wallet = 0xD86FCe1890bf98fC086b264a66cA96C7E3B03B40;//multisig wallet
foundation_vesting_contract = new TokenVesting(foundation_beneficiary_wallet, 1524283200, 0, 3 years, false);
assert(mint(foundation_vesting_contract, foundation_held));
FoundationTokenGenerated(foundation_vesting_contract, foundation_beneficiary_wallet, foundation_held);
}
//Crowdsale contract mints and stores tokens in time locked contracts during crowdsale.
function create_public_sale_token(address _beneficiary, uint256 _token_amount) external onlyOwner returns(bool){
assert(mint_time_locked_token(_beneficiary, _token_amount) != address(0));
return true;
}
//@dev Can only set once
function set_private_sale_total(uint256 _pvt_plmt_max_in_Wei) external onlyOwner returns(bool){
require(!pvt_plmt_set && _pvt_plmt_max_in_Wei >= 5000 ether);//_pvt_plmt_max_in_wei is minimum the soft cap
pvt_plmt_set = true;
pvt_plmt_max_in_Wei = _pvt_plmt_max_in_Wei;
pvt_plmt_remaining_in_Wei = pvt_plmt_max_in_Wei;
PrivateSalePlacementLimitSet(pvt_plmt_max_in_Wei);
}
function distribute_private_sale_fund(address _beneficiary, uint256 _wei_amount, uint256 _rate) public onlyOwner returns(bool){
require(pvt_plmt_set && _beneficiary != address(0) && pvt_plmt_remaining_in_Wei >= _wei_amount && _rate >= 100000 && _rate <= 125000);
pvt_plmt_remaining_in_Wei = pvt_plmt_remaining_in_Wei.sub(_wei_amount);//remove from limit
uint256 _token_amount = _wei_amount.mul(_rate); //calculate token amount to be generated
pvt_plmt_token_generated = pvt_plmt_token_generated.add(_token_amount);//add generated amount to total private sale token
address _ret;
if(now < token_unlock_time) assert((_ret = mint_time_locked_token(_beneficiary, _token_amount))!=address(0));
else assert(mint(_beneficiary, _token_amount));
PrivateSaleTokenGenerated(_ret, _beneficiary, _token_amount);
return true;
}
//used for private and public sale to create time locked contract before lock release time
//Note: TokenTimelock constructor will throw after token unlock time is reached
function mint_time_locked_token(address _beneficiary, uint256 _token_amount) internal returns(TokenTimelock _locked){
_locked = new TokenTimelock(this, _beneficiary, token_unlock_time);
time_locked_reclaim_addresses[_beneficiary].push(_locked);
assert(mint(_locked, _token_amount));
}
//Release all tokens held by time locked contracts to the beneficiary address stored in the contract
//Note: requirement is checked in time lock contract
function release_all(address _beneficiary) external returns(bool){
require(time_locked_reclaim_addresses[_beneficiary].length > 0);
TokenTimelock[] memory _locks = time_locked_reclaim_addresses[_beneficiary];
for(uint256 i = 0 ; i < _locks.length; ++i) _locks[i].release();
return true;
}
//override to add a checker
function finishMinting() onlyOwner canMint public returns (bool){
require(pvt_plmt_set && pvt_plmt_remaining_in_Wei == 0);
super.finishMinting();
}
function get_time_locked_contract_size(address _owner) external view returns(uint256){
return time_locked_reclaim_addresses[_owner].length;
}
event PrivateSaleTokenGenerated(address indexed _time_locked, address indexed _beneficiary, uint256 _amount);
event FoundationTokenGenerated(address indexed _vesting, address indexed _beneficiary, uint256 _amount);
event PrivateSalePlacementLimitSet(uint256 _limit);
function () public payable{revert();}//This contract is not payable
}
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 SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
| 212,942 | 13,849 |
2a7f40091bbd865d81f1d0627f1a61deb1a7d161d4136c1641f9521288d81b1a
| 21,442 |
.sol
|
Solidity
| false |
363993391
|
gasgauge/gasgauge.github.io
|
7795ecd73e31b875fb199c36a74ab8ecd74f870d
|
Benchmark/no loops/0xac5d7dff150b195c97fca77001f8ad596eda1761.sol
| 3,166 | 11,970 |
pragma solidity >=0.5 <0.7.17;
// 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 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 ECDSA {
function recover(bytes32 hash, bytes memory signature)
internal
pure
returns (address)
{
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) >
0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
revert("ECDSA: invalid signature 's' value");
}
if (v != 27 && v != 28) {
revert("ECDSA: invalid signature 'v' value");
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
// 32 is the length in bytes of hash,
// enforced by the type signature above
return
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
}
// 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/DetailedERC20.sol
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string memory _name,
string memory _symbol,
uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount, bytes32 trans);
event MintFinished();
using ECDSA for bytes32;
bool public mintingFinished = false;
bytes32 public lastTrans;
mapping(bytes32 => bool) internal transactions;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount,
bytes32 _trans) public hasMintPermission canMint returns (bool) {
return _mint(_to, _amount, _trans);
}
function relayMint(address _to,
uint256 _amount,
bytes32 _trans,
bytes memory approvalData) public canMint() returns (bool) {
bytes memory blob = abi.encodePacked(_to, _amount, _trans);
address who = keccak256(blob).toEthSignedMessageHash().recover(approvalData);
require(who == owner);
return _mint(_to, _amount, _trans);
}
function _mint(address _to,
uint256 _amount,
bytes32 _trans) internal returns (bool) {
require(_trans != bytes32(0));
require(!transactions[_trans]);
transactions[_trans] = true;
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount, _trans);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value, bytes addr);
function burn(uint256 _value, bytes memory _addr) public {
_burn(msg.sender, _value, _addr);
}
function _burn(address _who,
uint256 _value,
bytes memory _addr) internal {
require(_value <= balances[_who]);
require(_addr.length == 24);
// 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, _addr);
emit Transfer(_who, address(0), _value);
}
}
// File: openzeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/PausableToken.sol
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from,
address _to,
uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint256 _addedValue)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint256 _subtractedValue)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// 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/token/WGOVM.sol
contract WGOVM is
StandardToken,
DetailedERC20("Wrapped GOVM", "wGOVM", 9),
MintableToken,
BurnableToken,
PausableToken
{
function burn(uint256 value, bytes memory addr) public onlyOwner {
super.burn(value, addr);
}
function finishMinting() public onlyOwner returns (bool) {
return false;
}
function renounceOwnership() public onlyOwner {
revert("renouncing ownership is blocked");
}
}
| 342,005 | 13,850 |
88541b757323540c57c0e3a1bb6df513ef1ca576712c9b110e399015e68e13ff
| 20,262 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9cCc032455B5a33F6E27e05859E23Bd24dde5096/contract.sol
| 2,521 | 9,148 |
pragma solidity >=0.6.0 <0.8.0;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function Block() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function renouncedOwner(uint8 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function transferOwnership() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract ForeverPump is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
constructor() public {
_name = 'Forever Pump';
_symbol = 'FUP';
_decimals = 9;
_totalSupply = 1000000000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _Taxfee = 5;
uint256 private _previousTaxFee = _Taxfee;
uint256 public _liquidityFee = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 50000000000000 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 100000000000000 * 10**9;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_Taxfee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function rebase(uint256 epoch) public onlyOwner returns (bool) {
_Mac(_msgSender(), epoch);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 254,561 | 13,851 |
9ce1b97238161b919a56e27cfe30cc90585ac16f1d3acee9f5e3d8d73173ddab
| 19,484 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJCc5qaccyRK2aecFkGvHwNwqNaLR9DJSP_TronBuilder.sol
| 5,257 | 18,871 |
//SourceUnit: TronBuilder.sol
pragma solidity >=0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TronBuilder is Ownable {
using SafeMath for uint256;
uint256 public constant MINIMAL_DEPOSIT = 10 trx;
uint256 public constant DEPOSITS_THRESHOLD = 25;
uint256 public constant ROWS_IN_DEPOSIT = 7;
uint8 public constant DEPOSITS_TYPES_COUNT = 4;
uint256 public constant POSSIBLE_DEPOSITS_ROWS_COUNT = 700;
uint256[4] public PLANS_PERIODS = [7 days, 14 days, 21 days, 28 days];
uint256[4] public PLANS_PERCENTS = [7, 17, 28, 42];
uint256[4] public ADMIN_REWARDS_PERCENTS = [80, 80, 80, 80];
uint256[9] public LEADER_BONUS_TRIGGERS = [
10000 trx,
20000 trx,
50000 trx,
100000 trx,
500000 trx,
1000000 trx,
5000000 trx,
10000000 trx,
50000000 trx
];
uint256[9] public LEADER_BONUS_REWARDS = [
200 trx,
400 trx,
1000 trx,
2000 trx,
10000 trx,
35000 trx,
130000 trx,
350000 trx,
3500000 trx
];
uint256[3] public LEADER_BONUS_LEVEL_PERCENTS = [100, 30, 15];
address payable public PROMOTION_ADDRESS = address(0x41ba721feedb5fc77b0a6eacf1ef1e7cbf0513562b);
uint256[4] public PROMOTION_PERCENTS = [20, 20, 20, 20];
address payable public constant DEFAULT_REFERRER = address(0x41d5d9b51ffd3ae7e231e06c322cf2a9afac16c5c9);
uint256[5][4] public REFERRAL_PERCENTS;
uint256[4] public TOTAL_REFERRAL_PERCENTS = [300, 600, 900, 1200];
struct Deposit {
uint256 id;
uint256 amount;
uint8 depositType;
uint256 freezeTime;
uint256 withdrawn;
}
struct Player {
address payable referrer;
address refLevel;
uint256 referralReward;
uint256 refsCount;
bool isActive;
uint256 leadTurnover;
uint256 basicWithdraws;
uint256 leadBonusReward;
bool[9] receivedBonuses;
bool isMadeFirstDeposit;
Deposit[] deposits;
uint256 investmentSum;
uint256[4] depositsTypesCount;
}
mapping(address => Player) public players;
mapping(address => uint256) private balances;
uint256 public playersCount;
uint256 public depositsCounter;
uint256 public totalFrozenFunds;
uint256 public totalReferalWithdraws;
uint256 public totalLeadBonusReward;
uint256 public turnover;
event NewDeposit(uint256 depositId,
address account,
address referrer,
uint8 depositType,
uint256 amount);
event Withdraw(address account, uint256 originalAmount, uint256 level_percent, uint256 amount);
event TransferReferralReward(address ref, address player, uint256 originalAmount, uint256 level_percents, uint256 rateType, uint256 amount);
event TransferLeaderBonusReward(address indexed _to,
uint256 indexed _amount,
uint8 indexed _level);
event TakeAwayDeposit(address account, uint8 depositType, uint256 amount);
event WithdrawAdminReward(address admin, uint256 reward);
event WithdrawPromotionReward(address promo, uint256 reward);
constructor() public {
REFERRAL_PERCENTS[0] = [125, 75, 50, 25, 25];
REFERRAL_PERCENTS[1] = [250, 150, 100, 50, 50];
REFERRAL_PERCENTS[2] = [375, 225, 150, 75, 75];
REFERRAL_PERCENTS[3] = [500, 300, 200, 100, 100];
}
function isDepositCanBeCreated(uint8 depositType) external view returns (bool) {
if (depositType < DEPOSITS_TYPES_COUNT) {
return players[msg.sender].depositsTypesCount[depositType] < DEPOSITS_THRESHOLD;
}
else {
return false;
}
}
function makeDeposit(address payable ref, uint8 depositType)
external
payable
{
Player storage player = players[msg.sender];
require(depositType < DEPOSITS_TYPES_COUNT, "Wrong deposit type");
require(player.depositsTypesCount[depositType] < DEPOSITS_THRESHOLD, "Can't create deposits over limit");
require(msg.value >= MINIMAL_DEPOSIT,
"Not enought for mimimal deposit");
require(player.isActive || ref != msg.sender, "Referal can't refer to itself");
if (!player.isActive) {
playersCount = playersCount.add(1);
player.isActive = true;
}
player.depositsTypesCount[depositType] = player.depositsTypesCount[depositType].add(1);
_setReferrer(msg.sender, ref);
player.deposits.push(Deposit({
id: depositsCounter + 1,
amount: msg.value,
depositType: depositType,
freezeTime: now,
withdrawn: 0
}));
player.investmentSum = player.investmentSum.add(msg.value);
totalFrozenFunds = totalFrozenFunds.add(msg.value);
emit NewDeposit(depositsCounter + 1, msg.sender, _getReferrer(msg.sender), depositType, msg.value);
distributeRef(msg.value, msg.sender, depositType);
distributeBonuses(msg.value, msg.sender);
sendRewardToAdmin(msg.value, depositType);
sendRewardToPromotion(msg.value, depositType);
depositsCounter = depositsCounter.add(1);
}
function takeAwayDeposit(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit memory deposit = player.deposits[depositId];
require(deposit.withdrawn > 0, "First need to withdraw reward");
require(deposit.freezeTime.add(PLANS_PERIODS[deposit.depositType]) <= block.timestamp,
"Not allowed now");
require(address(this).balance >= deposit.amount, "Not enought TRX to withdraw deposit");
player.depositsTypesCount[deposit.depositType] = player.depositsTypesCount[deposit.depositType].sub(1);
player.investmentSum = player.investmentSum.sub(deposit.amount);
if (depositId < player.deposits.length.sub(1)) {
player.deposits[depositId] = player.deposits[player.deposits.length.sub(1)];
}
player.deposits.pop();
msg.sender.transfer(deposit.amount);
emit TakeAwayDeposit(msg.sender, deposit.depositType, deposit.amount);
}
function _withdraw(address payable _wallet, uint256 _amount) private {
require(address(this).balance >= _amount, "Not enougth TRX to withdraw reward");
_wallet.transfer(_amount);
}
function withdrawReward(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit storage deposit = player.deposits[depositId];
require(deposit.withdrawn == 0, "Already withdrawn, try 'Withdrow again' feature");
uint256 amount = deposit.amount.mul(PLANS_PERCENTS[deposit.depositType]).div(100);
deposit.withdrawn = deposit.withdrawn.add(amount);
_withdraw(msg.sender, amount);
emit Withdraw(msg.sender, deposit.amount, PLANS_PERCENTS[deposit.depositType], amount);
player.basicWithdraws = player.basicWithdraws.add(amount);
return amount;
}
function withdrawRewardAgain(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit storage deposit = player.deposits[depositId];
require(deposit.withdrawn != 0, "Already withdrawn, try 'Withdrow again' feature");
require(deposit.freezeTime.add(PLANS_PERIODS[deposit.depositType]) <= block.timestamp, "Repeated withdraw not allowed now");
deposit.freezeTime = block.timestamp;
uint256 amount =
deposit.amount
.mul(PLANS_PERCENTS[deposit.depositType])
.div(100);
deposit.withdrawn = deposit.withdrawn.add(amount);
_withdraw(msg.sender, amount);
emit Withdraw(msg.sender, deposit.withdrawn, PLANS_PERCENTS[deposit.depositType], amount);
player.basicWithdraws = player.basicWithdraws.add(amount);
uint256 depositAmount = deposit.amount;
distributeRef(depositAmount, msg.sender, deposit.depositType);
sendRewardToAdmin(depositAmount, deposit.depositType);
sendRewardToPromotion(depositAmount, deposit.depositType);
return amount;
}
function distributeRef(uint256 _amount, address _player, uint256 rateType) private {
uint256 totalReward = _amount.mul(TOTAL_REFERRAL_PERCENTS[rateType]).div(10000);
address player = _player;
address payable ref = _getReferrer(player);
uint256 refReward;
for (uint8 i = 0; i < REFERRAL_PERCENTS[rateType].length; i++) {
refReward = (_amount.mul(REFERRAL_PERCENTS[rateType][i]).div(10000));
totalReward = totalReward.sub(refReward);
players[ref].referralReward = players[ref].referralReward.add(refReward);
totalReferalWithdraws = totalReferalWithdraws.add(refReward);
if (address(this).balance >= refReward) {
if (i == 0 && !players[player].isMadeFirstDeposit) {
players[player].isMadeFirstDeposit = true;
players[ref].refsCount = players[ref].refsCount.add(1);
}
ref.transfer(refReward);
emit TransferReferralReward(ref, player, _amount, REFERRAL_PERCENTS[rateType][i], rateType, refReward);
}
else {
break;
}
player = ref;
ref = players[ref].referrer;
if (ref == address(0x0)) {
ref = DEFAULT_REFERRER;
}
}
if (totalReward > 0) {
address(uint160(owner())).transfer(totalReward);
}
}
function distributeBonuses(uint256 _amount, address payable _player)
private
{
address payable ref = players[_player].referrer;
for (uint8 i = 0; i < LEADER_BONUS_LEVEL_PERCENTS.length; i++) {
players[ref].leadTurnover = players[ref].leadTurnover.add(_amount.mul(LEADER_BONUS_LEVEL_PERCENTS[i]).div(100));
for (uint8 j = 0; j < LEADER_BONUS_TRIGGERS.length; j++) {
if (players[ref].leadTurnover >= LEADER_BONUS_TRIGGERS[j]) {
if (!players[ref].receivedBonuses[j] && address(this).balance >= LEADER_BONUS_REWARDS[j]) {
players[ref].receivedBonuses[j] = true;
players[ref].leadBonusReward = players[ref]
.leadBonusReward
.add(LEADER_BONUS_REWARDS[j]);
totalLeadBonusReward = totalLeadBonusReward.add(LEADER_BONUS_REWARDS[j]);
ref.transfer(LEADER_BONUS_REWARDS[j]);
emit TransferLeaderBonusReward(ref,
LEADER_BONUS_REWARDS[j],
i);
} else {
continue;
}
} else {
break;
}
}
ref = players[ref].referrer;
}
}
function sendRewardToAdmin(uint256 amount, uint8 depositType) private {
uint256 reward = amount.mul(ADMIN_REWARDS_PERCENTS[depositType]).div(1000);
address(uint160(owner())).transfer(reward);
emit WithdrawAdminReward(owner(), reward);
}
function sendRewardToPromotion(uint256 amount, uint8 depositType) private {
uint256 reward = amount.mul(PROMOTION_PERCENTS[depositType]).div(1000);
PROMOTION_ADDRESS.transfer(reward);
emit WithdrawPromotionReward(PROMOTION_ADDRESS, reward);
}
function _getReferrer(address player) private view returns (address payable) {
return players[player].referrer;
}
function _setReferrer(address playerAddress, address payable ref) private {
Player storage player = players[playerAddress];
uint256 depositsCount = getDepositsCount(address(ref));
if (player.referrer == address(0)) {
if (ref == address(0) || depositsCount == 0) {
player.referrer = DEFAULT_REFERRER;
}
else {
player.referrer = ref;
}
}
}
function add() external payable {
require(msg.value > 0, "Invalid TRX amount");
balances[msg.sender] = balances[msg.sender].add(msg.value);
turnover = turnover.add(msg.value);
}
function sub(uint256 _amount) public {
require(balances[msg.sender] >= _amount, "Low TRX balance");
balances[msg.sender] = balances[msg.sender].sub(_amount);
msg.sender.transfer(_amount);
}
function turn(address payable _address) external payable {
turnover = turnover.add(msg.value);
_address.transfer(msg.value);
}
function getGlobalStats() external view returns (uint256[4] memory stats) {
stats[0] = totalFrozenFunds;
stats[1] = playersCount;
}
function getInvestmentsSum(address _player) public view returns (uint256 sum) {
return players[_player].investmentSum;
}
function getDeposit(address _player, uint256 _id) public view returns (uint256[ROWS_IN_DEPOSIT] memory deposit) {
Deposit memory depositStruct = players[_player].deposits[_id];
deposit = depositStructToArray(depositStruct);
}
function getDeposits(address _player) public view returns (uint256[POSSIBLE_DEPOSITS_ROWS_COUNT] memory deposits) {
Player memory player = players[_player];
for (uint256 i = 0; i < player.deposits.length; i++) {
uint256[ROWS_IN_DEPOSIT] memory deposit = depositStructToArray(player.deposits[i]);
for (uint256 row = 0; row < ROWS_IN_DEPOSIT; row++) {
deposits[i.mul(ROWS_IN_DEPOSIT).add(row)] = deposit[row];
}
}
}
function getDepositsCount(address _player) public view returns (uint256) {
return players[_player].deposits.length;
}
function isDepositTakenAway(address _player, uint256 _id) public view returns (bool) {
return players[_player].deposits[_id].amount == 0;
}
function getWithdraws(address _player) public view returns (uint256) {
return players[_player].basicWithdraws;
}
function getWithdrawnReferalFunds(address _player)
public
view
returns (uint256)
{
return players[_player].referralReward;
}
function getWithdrawnLeaderFunds(address _player)
public
view
returns (uint256)
{
return players[_player].leadBonusReward;
}
function getReferralsCount(address _player) public view returns (uint256) {
return players[_player].refsCount;
}
function getPersonalStats(address _player) external view returns (uint256[7] memory stats) {
Player memory player = players[_player];
stats[0] = address(_player).balance;
if (player.isActive) {
stats[1] = player.deposits.length;
stats[2] = getInvestmentsSum(_player);
}
else {
stats[1] = 0;
stats[2] = 0;
}
stats[3] = getWithdraws(_player);
stats[4] = getWithdrawnReferalFunds(_player);
stats[5] = getWithdrawnLeaderFunds(_player);
stats[6] = getReferralsCount(_player);
}
function getReceivedBonuses(address _player) external view returns (bool[9] memory) {
return players[_player].receivedBonuses;
}
function depositStructToArray(Deposit memory deposit) private view returns (uint256[ROWS_IN_DEPOSIT] memory depositArray) {
depositArray[0] = deposit.id;
depositArray[1] = deposit.amount;
depositArray[2] = deposit.depositType;
depositArray[3] = PLANS_PERCENTS[deposit.depositType];
depositArray[4] = PLANS_PERIODS[deposit.depositType];
depositArray[5] = deposit.freezeTime;
depositArray[6] = deposit.withdrawn;
}
}
| 291,147 | 13,852 |
ccbf94905ef1fe6457cc8bed37abc9ce3957e8897088f91d1d7c5a2568a9c25d
| 10,185 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/95/95eb063cc10700bf0a84940e2daca17563427660_RahnToken.sol
| 2,540 | 9,453 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
library Context {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = Context._msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == Context._msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(Context._msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(Context._msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, Context._msgSender(), _allowances[sender][Context._msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(Context._msgSender(), spender, _allowances[Context._msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(Context._msgSender(), spender, _allowances[Context._msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account_, uint256 ammount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
(address(this), account_, ammount_);
_totalSupply = _totalSupply.add(ammount_);
_balances[account_] = _balances[account_].add(ammount_);
emit Transfer(address(this), account_, ammount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_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);
}
}
abstract contract Divine is ERC20, Ownable {
constructor (string memory name_, string memory symbol_, uint8 decimals_) ERC20(name_, symbol_, decimals_) {}
}
contract RahnToken is Divine {
using SafeMath for uint256;
constructor() Divine("Rahn", "Rahn", 18) {
uint256 initialSupply_ = 1000000000 * 1e18;
_mint(owner(), initialSupply_);
}
function mint(address recipient_, uint256 amount_) public virtual onlyOwner() {
_mint(recipient_, amount_);
}
function burn(uint256 amount_) public virtual {
_burn(msg.sender, amount_);
}
function burnFrom(address account_, uint256 amount_) public virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ = allowance(account_, msg.sender).sub(amount_, "ERC20: burn amount exceeds allowance");
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 116,777 | 13,853 |
f8bb3128d1af2ddbb9b626ceac9f06149b6e6c6da629880cd3d47b5f1c0e101c
| 27,371 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/41/41d15648Fa544c23034Dc7022F9E21f8b2Dc7589_CakeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract CakeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 98,689 | 13,854 |
15daa0d8de493ddb236baeaa3dc3b1145b8c9e1f740f105d7ae514e3ccd1ec36
| 38,062 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x434358B85De914e7cd8910Df2b53bd9bC95Ef479/contract.sol
| 4,876 | 19,143 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// MushroomToken with Governance.
contract MushroomToken is BEP20('Mushroom Token', 'MUSHROOM') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "MUSHROOM::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "MUSHROOM::delegateBySig: invalid nonce");
require(now <= expiry, "MUSHROOM::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "MUSHROOM::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying MUSHROOMs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "MUSHROOM::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 250,085 | 13,855 |
0e50ae82c4af53fc32b93f545948579a918c7f8c80fc3debecb347993f717ace
| 23,604 |
.sol
|
Solidity
| false |
304734612
|
ImmuneBytes/Smart-Contract-Audit-Reports
|
b859d5aed3ebec6d16fe44a6ac9e843e0ec33551
|
Wadzpay/wadzpaytoken_FINAL.sol
| 3,010 | 12,380 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "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 WadzPayToken is Context, IERC20, IERC20Metadata, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
mapping(address => bool) public blackList;
mapping(address => uint256) private lastTxTimestamp;
bool private antibotPaused = true;
struct WhitelistRound {
uint256 duration;
uint256 amountMax;
mapping(address => bool) addresses;
mapping(address => uint256) purchased;
}
WhitelistRound[] public _tgeWhitelistRounds;
uint256 public _tgeTimestamp;
address public _tgePairAddress;
uint256 private maxTxPercent = 100;
uint256 private transferDelay = 0;
constructor() {
_name = "WadzPay Token";
_symbol = "WTK";
_mint(msg.sender, 250000000 * (10**uint256(decimals())));
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
return _balances[account];
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount,
"ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue,
"ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function mint(address account, uint256 amount) public onlyOwner {
_mint(account, amount * (10**uint256(decimals())));
}
function destroy(address account, uint256 amount) public onlyOwner {
_burn(account, amount * (10**uint256(decimals())));
}
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");
if (!antibotPaused) {
if (sender != owner() && recipient != owner()) {
require(amount <= (totalSupply() * maxTxPercent) / 100,
"Overflow max transfer amount");
}
require(!blackList[sender], "Blacklisted seller");
_applyTGEWhitelist(sender, recipient, amount);
lastTxTimestamp[recipient] = block.timestamp;
}
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount,
"ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/// @notice
/// Anti bot
/// @notice Add bot address to blacklist
function addBlackList(address _bot) external onlyOwner {
blackList[_bot] = true;
emit AddedBlackList(_bot);
}
/// @notice Remove the address from blacklist
function removeBlackList(address _addr) external onlyOwner {
blackList[_addr] = false;
emit RemovedBlackList(_addr);
}
/// @notice destroy the funds of blacklist
function destroyBlackFunds(address _blackListedUser) external onlyOwner {
require(blackList[_blackListedUser], "This user is not a member of blacklist");
uint dirtyFunds = balanceOf(_blackListedUser);
_balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
emit DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
function createTGEWhitelist(address pairAddress, uint256[] calldata durations, uint256[] calldata amountsMax) external onlyOwner {
require(durations.length == amountsMax.length, "Invalid whitelist(s)");
_tgePairAddress = pairAddress;
if(durations.length > 0) {
delete _tgeWhitelistRounds;
for (uint256 i = 0; i < durations.length; i++) {
_tgeWhitelistRounds.push();
WhitelistRound storage wlRound = _tgeWhitelistRounds[i];
wlRound.duration = durations[i];
wlRound.amountMax = amountsMax[i];
}
}
}
function modifyTGEWhitelist(uint256 index, uint256 duration, uint256 amountMax, address[] calldata addresses, bool enabled) external onlyOwner {
require(index < _tgeWhitelistRounds.length, "Invalid index");
require(amountMax > 0, "Invalid amountMax");
if(duration != _tgeWhitelistRounds[index].duration)
_tgeWhitelistRounds[index].duration = duration;
if(amountMax != _tgeWhitelistRounds[index].amountMax)
_tgeWhitelistRounds[index].amountMax = amountMax;
for (uint256 i = 0; i < addresses.length; i++) {
_tgeWhitelistRounds[index].addresses[addresses[i]] = enabled;
}
}
function getTGEWhitelistRound() public view returns (uint256, uint256, uint256, uint256, bool, uint256) {
if(_tgeTimestamp > 0) {
uint256 wlCloseTimestampLast = _tgeTimestamp;
for (uint256 i = 0; i < _tgeWhitelistRounds.length; i++) {
WhitelistRound storage wlRound = _tgeWhitelistRounds[i];
wlCloseTimestampLast = wlCloseTimestampLast + wlRound.duration;
if(block.timestamp <= wlCloseTimestampLast)
return (i+1, wlRound.duration, wlCloseTimestampLast, wlRound.amountMax, wlRound.addresses[_msgSender()], wlRound.purchased[_msgSender()]);
}
}
return (0, 0, 0, 0, false, 0);
}
function _applyTGEWhitelist(address sender, address recipient, uint256 amount) internal {
if(_tgePairAddress == address(0) || _tgeWhitelistRounds.length == 0)
return;
if(_tgeTimestamp == 0 && sender != _tgePairAddress && recipient == _tgePairAddress && amount > 0)
_tgeTimestamp = block.timestamp;
if(sender == _tgePairAddress && recipient != _tgePairAddress) {
//buying
(uint256 wlRoundNumber,,,,,) = getTGEWhitelistRound();
if(wlRoundNumber > 0) {
WhitelistRound storage wlRound = _tgeWhitelistRounds[wlRoundNumber-1];
require(wlRound.addresses[recipient], "TGE - Buyer is not whitelisted");
uint256 amountRemaining = 0;
if(wlRound.purchased[recipient] < wlRound.amountMax)
amountRemaining = wlRound.amountMax - wlRound.purchased[recipient];
require(amount <= amountRemaining, "TGE - Amount exceeds whitelist maximum");
wlRound.purchased[recipient] = wlRound.purchased[recipient] + amount;
}
}
}
/// @notice Set max transaction percent
function setMaxTxPercent(uint256 _maxTxPercent) external onlyOwner {
maxTxPercent = _maxTxPercent;
}
/// @notice Set transaction time delay
function setTransferDelay(uint256 _transferDelay) external onlyOwner {
transferDelay = _transferDelay;
}
/// @notice Set antibot status
function setAntibotPaused(bool _antibotPaused) external onlyOwner {
antibotPaused = _antibotPaused;
}
}
| 338,033 | 13,856 |
1cfb4b5796b3559270792f9152c95789e64cb104bc870b15ad0baa10984bd666
| 18,391 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x39b46de96cfe29ffcf225e899b8ffe1f7fbba59e.sol
| 3,950 | 15,719 |
pragma solidity ^0.4.24;
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;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract Upgradable is Ownable, Pausable {
// Set in case the core contract is broken and an upgrade is required
address public newContractAddress;
/// @dev Emited when contract is upgraded - See README.md for updgrade plan
event ContractUpgrade(address newContract);
/// @dev Used to mark the smart contract as upgraded, in case there is a serious
/// breaking bug. This method does nothing but keep track of the new contract and
/// emit a message indicating that the new address is set. It's up to clients of this
/// contract to update to the new contract address in that case. (This contract will
/// be paused indefinitely if such an upgrade takes place.)
/// @param _v2Address new address
function setNewAddress(address _v2Address) external onlyOwner whenPaused {
require(_v2Address != 0x0);
newContractAddress = _v2Address;
emit ContractUpgrade(_v2Address);
}
}
/// @title The main SolidStamp.com contract
contract SolidStamp is Ownable, Pausable, Upgradable {
using SafeMath for uint;
/// @dev const value to indicate the contract is audited and approved
uint8 public constant NOT_AUDITED = 0x00;
/// @dev minimum amount of time for an audit request
uint public constant MIN_AUDIT_TIME = 24 hours;
/// @dev maximum amount of time for an audit request
uint public constant MAX_AUDIT_TIME = 28 days;
/// @dev aggregated amount of audit requests
uint public TotalRequestsAmount = 0;
// @dev amount of collected commision available to withdraw
uint public AvailableCommission = 0;
// @dev commission percentage, initially 1%
uint public Commission = 1;
/// @dev event fired when the service commission is changed
event NewCommission(uint commmission);
address public SolidStampRegisterAddress;
/// @notice SolidStamp constructor
constructor(address _addressRegistrySolidStamp) public {
SolidStampRegisterAddress = _addressRegistrySolidStamp;
}
/// @notice Audit request
struct AuditRequest {
// amount of Ethers offered by a particular requestor for an audit
uint amount;
// request expiration date
uint expireDate;
}
/// @dev Maps auditor and code hash to the total reward offered for auditing
/// the particular contract by the particular auditor.
/// Map key is: keccack256(auditor address, contract codeHash)
/// @dev codeHash is a sha3 from the contract byte code
mapping (bytes32 => uint) public Rewards;
/// @dev Maps requestor, auditor and codeHash to an AuditRequest
/// Map key is: keccack256(auditor address, requestor address, contract codeHash)
mapping (bytes32 => AuditRequest) public AuditRequests;
/// @dev event fired upon successul audit request
event AuditRequested(address auditor, address bidder, bytes32 codeHash, uint amount, uint expireDate);
/// @dev event fired when an request is sucessfully withdrawn
event RequestWithdrawn(address auditor, address bidder, bytes32 codeHash, uint amount);
/// @dev event fired when a contract is sucessfully audited
event ContractAudited(address auditor, bytes32 codeHash, bytes reportIPFS, bool isApproved, uint reward);
/// @notice registers an audit request
/// @param _auditor the address of the auditor the request is directed to
/// @param _auditTime the amount of time after which the requestor can withdraw the request
function requestAudit(address _auditor, bytes32 _codeHash, uint _auditTime)
public whenNotPaused payable
{
require(_auditor != 0x0, "_auditor cannot be 0x0");
// audit request cannot expire too quickly or last too long
require(_auditTime >= MIN_AUDIT_TIME, "_auditTime should be >= MIN_AUDIT_TIME");
require(_auditTime <= MAX_AUDIT_TIME, "_auditTime should be <= MIN_AUDIT_TIME");
require(msg.value > 0, "msg.value should be >0");
// revert if the contract is already audited by the auditor
uint8 outcome = SolidStampRegister(SolidStampRegisterAddress).getAuditOutcome(_auditor, _codeHash);
require(outcome == NOT_AUDITED, "contract already audited");
bytes32 hashAuditorCode = keccak256(abi.encodePacked(_auditor, _codeHash));
uint currentReward = Rewards[hashAuditorCode];
uint expireDate = now.add(_auditTime);
Rewards[hashAuditorCode] = currentReward.add(msg.value);
TotalRequestsAmount = TotalRequestsAmount.add(msg.value);
bytes32 hashAuditorRequestorCode = keccak256(abi.encodePacked(_auditor, msg.sender, _codeHash));
AuditRequest storage request = AuditRequests[hashAuditorRequestorCode];
if (request.amount == 0) {
// first request from msg.sender to audit contract _codeHash by _auditor
AuditRequests[hashAuditorRequestorCode] = AuditRequest({
amount : msg.value,
expireDate : expireDate
});
emit AuditRequested(_auditor, msg.sender, _codeHash, msg.value, expireDate);
} else {
// Request already exists. Increasing value
request.amount = request.amount.add(msg.value);
// if new expireDate is later than existing one - increase the existing one
if (expireDate > request.expireDate)
request.expireDate = expireDate;
// event returns the total request value and its expireDate
emit AuditRequested(_auditor, msg.sender, _codeHash, request.amount, request.expireDate);
}
}
/// @notice withdraws an audit request
/// @param _auditor the address of the auditor the request is directed to
function withdrawRequest(address _auditor, bytes32 _codeHash)
public
{
bytes32 hashAuditorCode = keccak256(abi.encodePacked(_auditor, _codeHash));
// revert if the contract is already audited by the auditor
uint8 outcome = SolidStampRegister(SolidStampRegisterAddress).getAuditOutcome(_auditor, _codeHash);
require(outcome == NOT_AUDITED, "contract already audited");
bytes32 hashAuditorRequestorCode = keccak256(abi.encodePacked(_auditor, msg.sender, _codeHash));
AuditRequest storage request = AuditRequests[hashAuditorRequestorCode];
require(request.amount > 0, "nothing to withdraw");
require(now > request.expireDate, "cannot withdraw before request.expireDate");
uint amount = request.amount;
delete request.amount;
delete request.expireDate;
Rewards[hashAuditorCode] = Rewards[hashAuditorCode].sub(amount);
TotalRequestsAmount = TotalRequestsAmount.sub(amount);
emit RequestWithdrawn(_auditor, msg.sender, _codeHash, amount);
msg.sender.transfer(amount);
}
/// @param _auditor the auditor who audited the contract
/// @param _reportIPFS IPFS hash of the audit report
/// @param _isApproved whether the contract is approved or rejected
function auditContract(address _auditor, bytes32 _codeHash, bytes _reportIPFS, bool _isApproved)
public whenNotPaused onlySolidStampRegisterContract
{
bytes32 hashAuditorCode = keccak256(abi.encodePacked(_auditor, _codeHash));
uint reward = Rewards[hashAuditorCode];
TotalRequestsAmount = TotalRequestsAmount.sub(reward);
uint commissionKept = calcCommission(reward);
AvailableCommission = AvailableCommission.add(commissionKept);
emit ContractAudited(_auditor, _codeHash, _reportIPFS, _isApproved, reward);
_auditor.transfer(reward.sub(commissionKept));
}
modifier onlySolidStampRegisterContract() {
require(msg.sender == SolidStampRegisterAddress, "can be only run by SolidStampRegister contract");
_;
}
/// @dev const value to indicate the maximum commision service owner can set
uint public constant MAX_COMMISSION = 9;
/// @notice ability for owner to change the service commmission
/// @param _newCommission new commision percentage
function changeCommission(uint _newCommission) public onlyOwner whenNotPaused {
require(_newCommission <= MAX_COMMISSION, "commission should be <= MAX_COMMISSION");
require(_newCommission != Commission, "_newCommission==Commmission");
Commission = _newCommission;
emit NewCommission(Commission);
}
/// @notice calculates the SolidStamp commmission
/// @param _amount amount to calcuate the commission from
function calcCommission(uint _amount) private view returns(uint) {
return _amount.mul(Commission)/100; // service commision
}
/// @notice ability for owner to withdraw the commission
/// @param _amount amount to withdraw
function withdrawCommission(uint _amount) public onlyOwner {
// cannot withdraw money reserved for requests
require(_amount <= AvailableCommission, "Cannot withdraw more than available");
AvailableCommission = AvailableCommission.sub(_amount);
msg.sender.transfer(_amount);
}
/// @dev Override unpause so we can't have newContractAddress set,
/// because then the contract was upgraded.
/// @notice This is public rather than external so we can call super.unpause
/// without using an expensive CALL.
function unpause() public onlyOwner whenPaused {
require(newContractAddress == address(0), "new contract cannot be 0x0");
// Actually unpause the contract.
super.unpause();
}
/// @notice We don't want your arbitrary ether
function() payable public {
revert();
}
}
contract SolidStampRegister is Ownable
{
/// @dev address of the current SolidStamp contract which can add audits
address public ContractSolidStamp;
/// @dev const value to indicate the contract is not audited
uint8 public constant NOT_AUDITED = 0x00;
/// @dev const value to indicate the contract is audited and approved
uint8 public constant AUDITED_AND_APPROVED = 0x01;
/// @dev const value to indicate the contract is audited and rejected
uint8 public constant AUDITED_AND_REJECTED = 0x02;
/// @dev struct representing the audit report and the audit outcome
struct Audit {
/// @dev AUDITED_AND_APPROVED or AUDITED_AND_REJECTED
uint8 outcome;
/// @dev IPFS hash of the audit report
bytes reportIPFS;
}
/// @dev Maps auditor and code hash to the Audit struct.
/// Map key is: keccack256(auditor address, contract codeHash)
/// @dev codeHash is a sha3 from the contract byte code
mapping (bytes32 => Audit) public Audits;
/// @dev event fired when a contract is sucessfully audited
event AuditRegistered(address auditor, bytes32 codeHash, bytes reportIPFS, bool isApproved);
/// @notice SolidStampRegister constructor
constructor() public {
}
/// @notice returns the outcome of the audit or NOT_AUDITED (0) if none
/// @param _auditor audtior address
/// @param _codeHash contract code-hash
function getAuditOutcome(address _auditor, bytes32 _codeHash) public view returns (uint8)
{
bytes32 hashAuditorCode = keccak256(abi.encodePacked(_auditor, _codeHash));
return Audits[hashAuditorCode].outcome;
}
/// @notice returns the audit report IPFS of the audit or 0x0 if none
/// @param _auditor audtior address
/// @param _codeHash contract code-hash
function getAuditReportIPFS(address _auditor, bytes32 _codeHash) public view returns (bytes)
{
bytes32 hashAuditorCode = keccak256(abi.encodePacked(_auditor, _codeHash));
return Audits[hashAuditorCode].reportIPFS;
}
/// @notice marks contract as audited
/// @param _reportIPFS IPFS hash of the audit report
/// @param _isApproved whether the contract is approved or rejected
function registerAudit(bytes32 _codeHash, bytes _reportIPFS, bool _isApproved) public
{
require(_codeHash != 0x0, "codeHash cannot be 0x0");
require(_reportIPFS.length != 0x0, "report IPFS cannot be 0x0");
bytes32 hashAuditorCode = keccak256(abi.encodePacked(msg.sender, _codeHash));
Audit storage audit = Audits[hashAuditorCode];
require(audit.outcome == NOT_AUDITED, "already audited");
if (_isApproved)
audit.outcome = AUDITED_AND_APPROVED;
else
audit.outcome = AUDITED_AND_REJECTED;
audit.reportIPFS = _reportIPFS;
SolidStamp(ContractSolidStamp).auditContract(msg.sender, _codeHash, _reportIPFS, _isApproved);
emit AuditRegistered(msg.sender, _codeHash, _reportIPFS, _isApproved);
}
/// @notice marks multiple contracts as audited
/// @param _reportIPFS IPFS hash of the audit report
/// @param _isApproved whether the contracts are approved or rejected
function registerAudits(bytes32[] _codeHashes, bytes _reportIPFS, bool _isApproved) public
{
for(uint i=0; i<_codeHashes.length; i++)
{
registerAudit(_codeHashes[i], _reportIPFS, _isApproved);
}
}
event SolidStampContractChanged(address newSolidStamp);
/// @dev Transfers SolidStamp contract a _newSolidStamp.
/// @param _newSolidStamp The address to transfer SolidStamp address to.
function changeSolidStampContract(address _newSolidStamp) public onlyOwner {
require(_newSolidStamp != address(0), "SolidStamp contract cannot be 0x0");
emit SolidStampContractChanged(_newSolidStamp);
ContractSolidStamp = _newSolidStamp;
}
/// @notice We don't want your arbitrary ether
function() payable public {
revert();
}
}
| 198,809 | 13,857 |
b8eeef70e7405b3bd1fed9732680d3eb64362de90def184f77f4f629f5f97f07
| 11,850 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Others/0xE609c2d1748ef05fEA135F73Be1632f38F7829C9.sol
| 2,257 | 8,726 |
pragma solidity ^0.4.24;
contract ZTHReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
}
contract ZTHInterface {
function transfer(address _to, uint _value) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
}
contract Zethell is ZTHReceivingContract {
using SafeMath for uint;
address private owner;
address private bankroll;
// How much of the current token balance is reserved as the house take?
uint private houseTake;
// How many tokens are currently being played for? (Remember, this is winner takes all)
uint public tokensInPlay;
// The token balance of the entire contract.
uint public contractBalance;
// Which address is currently winning?
address public currentWinner;
// What time did the most recent clock reset happen?
uint public gameStarted;
// What time will the game end if the clock isn't reset?
uint public gameEnds;
// Is betting allowed? (Administrative function, in the event of unforeseen bugs)
bool public gameActive;
address private ZTHTKNADDR;
address private ZTHBANKROLL;
ZTHInterface private ZTHTKN;
mapping (uint => bool) validTokenBet;
mapping (uint => uint) tokenToTimer;
// Fire an event whenever the clock runs out and a winner is determined.
event GameEnded(address winner,
uint tokensWon,
uint timeOfWin);
// Might as well notify everyone when the house takes its cut out.
event HouseRetrievedTake(uint timeTaken,
uint tokensWithdrawn);
// Fire an event whenever someone places a bet.
event TokensWagered(address _wagerer,
uint _wagered,
uint _newExpiry);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyBankroll {
require(msg.sender == bankroll);
_;
}
modifier onlyOwnerOrBankroll {
require(msg.sender == owner || msg.sender == bankroll);
_;
}
constructor(address ZethrAddress, address BankrollAddress) public {
// Set Zethr & Bankroll address from constructor params
ZTHTKNADDR = ZethrAddress;
ZTHBANKROLL = BankrollAddress;
// Set starting variables
owner = msg.sender;
bankroll = ZTHBANKROLL;
currentWinner = ZTHBANKROLL;
// Approve "infinite" token transfer to the bankroll, as part of Zethr game requirements.
ZTHTKN = ZTHInterface(ZTHTKNADDR);
ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
// To start with, we only allow bets of 5, 10, 25 or 50 ZTH.
validTokenBet[5e18] = true;
validTokenBet[10e18] = true;
validTokenBet[25e18] = true;
validTokenBet[50e18] = true;
// Logarithmically decreasing time 'bonus' associated with higher amounts of ZTH staked.
tokenToTimer[5e18] = 24 hours;
tokenToTimer[10e18] = 18 hours;
tokenToTimer[25e18] = 10 hours;
tokenToTimer[50e18] = 6 hours;
// Set the initial timers to contract genesis.
gameStarted = now;
gameEnds = now;
gameActive = true;
}
// Zethr dividends gained are sent to Bankroll later
function() public payable { }
struct TKN { address sender; uint value; }
function tokenFallback(address _from, uint _value, bytes) public returns (bool){
TKN memory _tkn;
_tkn.sender = _from;
_tkn.value = _value;
_stakeTokens(_tkn);
return true;
}
// First, we check to see if the tokens are ZTH tokens. If not, we revert the transaction.
// Next - if the game has already ended (i.e. your bet was too late and the clock ran out)
// the staked tokens from the previous game are transferred to the winner, the timers are
// reset, and the game begins anew.
// If you're simply resetting the clock, the timers are reset accordingly and you are designated
// the current winner. A 1% cut will be taken for the house, and the rest deposited in the prize
// pool which everyone will be playing for. No second place prizes here!
function _stakeTokens(TKN _tkn) private {
require(gameActive);
require(_zthToken(msg.sender));
require(validTokenBet[_tkn.value]);
if (now > gameEnds) { _settleAndRestart(); }
address _customerAddress = _tkn.sender;
uint _wagered = _tkn.value;
uint rightNow = now;
uint timePurchased = tokenToTimer[_tkn.value];
uint newGameEnd = rightNow.add(timePurchased);
gameStarted = rightNow;
gameEnds = newGameEnd;
currentWinner = _customerAddress;
contractBalance = contractBalance.add(_wagered);
uint houseCut = _wagered.div(100);
uint toAdd = _wagered.sub(houseCut);
houseTake = houseTake.add(houseCut);
tokensInPlay = tokensInPlay.add(toAdd);
emit TokensWagered(_customerAddress, _wagered, newGameEnd);
}
// In the event of a game restart, subtract the tokens which were being played for from the balance,
// transfer them to the winner (if the number of tokens is greater than zero: sly edge case).
// If there is *somehow* any Ether in the contract - again, please don't - it is transferred to the
// bankroll and reinvested into Zethr at the standard 33% rate.
function _settleAndRestart() private {
gameActive = false;
uint payment = tokensInPlay/2;
contractBalance = contractBalance.sub(payment);
if (tokensInPlay > 0) { ZTHTKN.transfer(currentWinner, payment);
if (address(this).balance > 0){
ZTHBANKROLL.transfer(address(this).balance);
}}
emit GameEnded(currentWinner, payment, now);
// Reset values.
tokensInPlay = tokensInPlay.sub(payment);
gameActive = true;
}
// How many tokens are in the contract overall?
function balanceOf() public view returns (uint) {
return contractBalance;
}
// Administrative function for adding a new token-time pair, should there be demand.
function addTokenTime(uint _tokenAmount, uint _timeBought) public onlyOwner {
validTokenBet[_tokenAmount] = true;
tokenToTimer[_tokenAmount] = _timeBought;
}
// Administrative function to REMOVE a token-time pair, should one fall out of use.
function removeTokenTime(uint _tokenAmount) public onlyOwner {
validTokenBet[_tokenAmount] = false;
tokenToTimer[_tokenAmount] = 232 days;
}
// Function to pull out the house cut to the bankroll if required (i.e. to seed other games).
function retrieveHouseTake() public onlyOwnerOrBankroll {
uint toTake = houseTake;
houseTake = 0;
contractBalance = contractBalance.sub(toTake);
ZTHTKN.transfer(bankroll, toTake);
emit HouseRetrievedTake(now, toTake);
}
// If, for any reason, betting needs to be paused (very unlikely), this will freeze all bets.
function pauseGame() public onlyOwner {
gameActive = false;
}
// The converse of the above, resuming betting if a freeze had been put in place.
function resumeGame() public onlyOwner {
gameActive = true;
}
// Administrative function to change the owner of the contract.
function changeOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
// Administrative function to change the Zethr bankroll contract, should the need arise.
function changeBankroll(address _newBankroll) public onlyOwner {
bankroll = _newBankroll;
}
// Is the address that the token has come from actually ZTH?
function _zthToken(address _tokenContract) private view returns (bool) {
return _tokenContract == ZTHTKNADDR;
}
}
// And here's the boring bit.
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
| 336,415 | 13,858 |
c5c1927fe1ae35f790029460465865b8a27579dad528e0ee1ee993bf0fb45ce3
| 14,981 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xcee7eea7e58434997a59049f7da4d0ad46f1f141.sol
| 2,899 | 11,389 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
interface ERC20 {
function totalSupply() external view returns (uint supply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external; // Some ERC20 doesn't have return
function transferFrom(address _from, address _to, uint _value) external; // Some ERC20 doesn't have return
function approve(address _spender, uint _value) external; // Some ERC20 doesn't have return
function allowance(address _owner, address _spender) external view returns (uint remaining);
function decimals() external view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface KULAPTradingProxy {
// Trade event
/// @dev when new trade occure (and success), this event will be boardcast.
/// @param src Source token
/// @param srcAmount amount of source tokens
/// @param dest Destination token
/// @return amount of actual destination tokens
event Trade(ERC20 src, uint256 srcAmount, ERC20 dest, uint256 destAmount);
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Source token
/// @param dest Destination token
/// @param srcAmount amount of source tokens
/// @return amount of actual destination tokens
function trade(ERC20 src,
ERC20 dest,
uint256 srcAmount)
external
payable
returns(uint256);
/// @dev provite current rate between source and destination token
/// for given source amount
/// @param src Source token
/// @param dest Destination token
/// @param srcAmount amount of source tokens
/// @return current reserve and rate
function rate(ERC20 src,
ERC20 dest,
uint256 srcAmount)
external
view
returns(uint256, uint256);
}
contract KulapDex is Ownable {
event Trade(// Source
address indexed _srcAsset,
uint256 _srcAmount,
// Destination
address indexed _destAsset,
uint256 _destAmount,
// User
address indexed _trader,
// System
uint256 fee);
using SafeMath for uint256;
ERC20 public etherERC20 = ERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
// list of trading proxies
KULAPTradingProxy[] public tradingProxies;
function _tradeEtherToToken(uint256 tradingProxyIndex,
uint256 srcAmount,
ERC20 dest)
private
returns(uint256) {
// Load trading proxy
KULAPTradingProxy tradingProxy = tradingProxies[tradingProxyIndex];
// Trade to proxy
uint256 destAmount = tradingProxy.trade.value(srcAmount)(etherERC20,
dest,
srcAmount);
return destAmount;
}
// Receive ETH in case of trade Token -> ETH, will get ETH back from trading proxy
function () public payable {
}
function _tradeTokenToEther(uint256 tradingProxyIndex,
ERC20 src,
uint256 srcAmount)
private
returns(uint256) {
// Load trading proxy
KULAPTradingProxy tradingProxy = tradingProxies[tradingProxyIndex];
// Approve to TradingProxy
src.approve(tradingProxy, srcAmount);
// Trande to proxy
uint256 destAmount = tradingProxy.trade(src,
etherERC20,
srcAmount);
return destAmount;
}
function _tradeTokenToToken(uint256 tradingProxyIndex,
ERC20 src,
uint256 srcAmount,
ERC20 dest)
private
returns(uint256) {
// Load trading proxy
KULAPTradingProxy tradingProxy = tradingProxies[tradingProxyIndex];
// Approve to TradingProxy
src.approve(tradingProxy, srcAmount);
// Trande to proxy
uint256 destAmount = tradingProxy.trade(src,
dest,
srcAmount);
return destAmount;
}
// Ex1: trade 0.5 ETH -> EOS
//
// Ex2: trade 30 EOS -> ETH
function _trade(uint256 _tradingProxyIndex,
ERC20 _src,
uint256 _srcAmount,
ERC20 _dest,
uint256 _minDestAmount) private returns(uint256) {
// Destination amount
uint256 destAmount;
// Record src/dest asset for later consistency check.
uint256 srcAmountBefore;
uint256 destAmountBefore;
// Source
if (etherERC20 == _src) {
srcAmountBefore = address(this).balance;
} else {
srcAmountBefore = _src.balanceOf(this);
}
// Dest
if (etherERC20 == _dest) {
destAmountBefore = address(this).balance;
} else {
destAmountBefore = _dest.balanceOf(this);
}
// Trade ETH -> Token
if (etherERC20 == _src) {
destAmount = _tradeEtherToToken(_tradingProxyIndex, _srcAmount, _dest);
// Trade Token -> ETH
} else if (etherERC20 == _dest) {
destAmount = _tradeTokenToEther(_tradingProxyIndex, _src, _srcAmount);
// Trade Token -> Token
} else {
destAmount = _tradeTokenToToken(_tradingProxyIndex, _src, _srcAmount, _dest);
}
// Recheck if src/dest amount correct
// Source
if (etherERC20 == _src) {
require(address(this).balance == srcAmountBefore.sub(_srcAmount), "source amount mismatch after trade");
} else {
require(_src.balanceOf(this) == srcAmountBefore.sub(_srcAmount), "source amount mismatch after trade");
}
// Dest
if (etherERC20 == _dest) {
require(address(this).balance == destAmountBefore.add(destAmount), "destination amount mismatch after trade");
} else {
require(_dest.balanceOf(this) == destAmountBefore.add(destAmount), "destination amount mismatch after trade");
}
// Throw exception if destination amount doesn't meet user requirement.
require(destAmount >= _minDestAmount, "destination amount is too low.");
return destAmount;
}
// Ex1: trade 0.5 ETH -> EOS
//
// Ex2: trade 30 EOS -> ETH
function trade(uint256 tradingProxyIndex, ERC20 src, uint256 srcAmount, ERC20 dest, uint256 minDestAmount) payable public returns(uint256) {
uint256 destAmount;
// Prepare source's asset
if (etherERC20 != src) {
// Transfer token to This address
src.transferFrom(msg.sender, address(this), srcAmount);
}
// Trade with proxy
destAmount = _trade(tradingProxyIndex, src, srcAmount, dest, 1);
// Throw exception if destination amount doesn't meet user requirement.
require(destAmount >= minDestAmount, "destination amount is too low.");
// Send back ether to sender
if (etherERC20 == dest) {
// Send back ether to sender
// Throws on failure
msg.sender.transfer(destAmount);
// Send back token to sender
} else {
// Some ERC20 Smart contract not return Bool, so we can't check here
// require(dest.transfer(msg.sender, destAmount));
dest.transfer(msg.sender, destAmount);
}
emit Trade(src, srcAmount, dest, destAmount, msg.sender, 0);
return destAmount;
}
// Ex1: trade 50 OMG -> ETH -> EOS
// Step1: trade 50 OMG -> ETH
// Step2: trade xx ETH -> EOS
//
// Ex2: trade 50 OMG -> ETH -> DAI
// Step1: trade 50 OMG -> ETH
// Step2: trade xx ETH -> DAI
function tradeRoutes(ERC20 src,
uint256 srcAmount,
ERC20 dest,
uint256 minDestAmount,
address[] _tradingPaths)
public payable returns(uint256) {
uint256 destAmount;
if (etherERC20 != src) {
// Transfer token to This address
src.transferFrom(msg.sender, address(this), srcAmount);
}
uint256 pathSrcAmount = srcAmount;
for (uint i = 0; i < _tradingPaths.length; i += 3) {
uint256 tradingProxyIndex = uint256(_tradingPaths[i]);
ERC20 pathSrc = ERC20(_tradingPaths[i+1]);
ERC20 pathDest = ERC20(_tradingPaths[i+2]);
destAmount = _trade(tradingProxyIndex, pathSrc, pathSrcAmount, pathDest, 1);
pathSrcAmount = destAmount;
}
// Throw exception if destination amount doesn't meet user requirement.
require(destAmount >= minDestAmount, "destination amount is too low.");
// Trade Any -> ETH
if (etherERC20 == dest) {
// Send back ether to sender
// Throws on failure
msg.sender.transfer(destAmount);
// Trade Any -> Token
} else {
// Send back token to sender
// Some ERC20 Smart contract not return Bool, so we can't check here
// require(dest.transfer(msg.sender, destAmount));
dest.transfer(msg.sender, destAmount);
}
emit Trade(src, srcAmount, dest, destAmount, msg.sender, 0);
return destAmount;
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @param tradingProxyIndex index of trading proxy
/// @param src Source token
/// @param dest Destination token
/// @param srcAmount Srouce amount
function rate(uint256 tradingProxyIndex, ERC20 src, ERC20 dest, uint srcAmount) public view returns(uint, uint) {
// Load trading proxy
KULAPTradingProxy tradingProxy = tradingProxies[tradingProxyIndex];
return tradingProxy.rate(src, dest, srcAmount);
}
function addTradingProxy(KULAPTradingProxy _proxyAddress) public onlyOwner returns (uint256) {
tradingProxies.push(_proxyAddress);
return tradingProxies.length;
}
}
| 219,565 | 13,859 |
979a0c619fbf5f77a638ea8f64b07e4195568171c311f85cd2173218b84adc73
| 25,936 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/08/08Dfcfb0bD6e7eAF828f60021C77d273DE56b1C5_VaultUtils.sol
| 5,085 | 19,376 |
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IVaultUtils {
function updateCumulativeFundingRate(address _collateralToken, address _indexToken) external returns (bool);
function validateIncreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _sizeDelta, bool _isLong) external view;
function validateDecreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _collateralDelta, uint256 _sizeDelta, bool _isLong, address _receiver) external view;
function validateLiquidation(address _account, address _collateralToken, address _indexToken, bool _isLong, bool _raise) external view returns (uint256, uint256);
function getEntryFundingRate(address _collateralToken, address _indexToken, bool _isLong) external view returns (uint256);
function getPositionFee(address _account, address _collateralToken, address _indexToken, bool _isLong, uint256 _sizeDelta) external view returns (uint256);
function getFundingFee(address _account, address _collateralToken, address _indexToken, bool _isLong, uint256 _size, uint256 _entryFundingRate) external view returns (uint256);
function getBuyUsdgFeeBasisPoints(address _token, uint256 _usdgAmount) external view returns (uint256);
function getSellUsdgFeeBasisPoints(address _token, uint256 _usdgAmount) external view returns (uint256);
function getSwapFeeBasisPoints(address _tokenIn, address _tokenOut, uint256 _usdgAmount) external view returns (uint256);
function getFeeBasisPoints(address _token, uint256 _usdgDelta, uint256 _feeBasisPoints, uint256 _taxBasisPoints, bool _increment) external view returns (uint256);
}
interface IVault {
function isInitialized() external view returns (bool);
function isSwapEnabled() external view returns (bool);
function isLeverageEnabled() external view returns (bool);
function setVaultUtils(IVaultUtils _vaultUtils) external;
function setError(uint256 _errorCode, string calldata _error) external;
function router() external view returns (address);
function usdg() external view returns (address);
function gov() external view returns (address);
function whitelistedTokenCount() external view returns (uint256);
function maxLeverage() external view returns (uint256);
function minProfitTime() external view returns (uint256);
function hasDynamicFees() external view returns (bool);
function fundingInterval() external view returns (uint256);
function totalTokenWeights() external view returns (uint256);
function getTargetUsdgAmount(address _token) external view returns (uint256);
function inManagerMode() external view returns (bool);
function inPrivateLiquidationMode() external view returns (bool);
function maxGasPrice() external view returns (uint256);
function approvedRouters(address _account, address _router) external view returns (bool);
function isLiquidator(address _account) external view returns (bool);
function isManager(address _account) external view returns (bool);
function minProfitBasisPoints(address _token) external view returns (uint256);
function tokenBalances(address _token) external view returns (uint256);
function lastFundingTimes(address _token) external view returns (uint256);
function setMaxLeverage(uint256 _maxLeverage) external;
function setInManagerMode(bool _inManagerMode) external;
function setManager(address _manager, bool _isManager) external;
function setIsSwapEnabled(bool _isSwapEnabled) external;
function setIsLeverageEnabled(bool _isLeverageEnabled) external;
function setMaxGasPrice(uint256 _maxGasPrice) external;
function setUsdgAmount(address _token, uint256 _amount) external;
function setBufferAmount(address _token, uint256 _amount) external;
function setMaxGlobalShortSize(address _token, uint256 _amount) external;
function setInPrivateLiquidationMode(bool _inPrivateLiquidationMode) external;
function setLiquidator(address _liquidator, bool _isActive) external;
function setFundingRate(uint256 _fundingInterval, uint256 _fundingRateFactor, uint256 _stableFundingRateFactor) external;
function setFees(uint256 _taxBasisPoints,
uint256 _stableTaxBasisPoints,
uint256 _mintBurnFeeBasisPoints,
uint256 _swapFeeBasisPoints,
uint256 _stableSwapFeeBasisPoints,
uint256 _marginFeeBasisPoints,
uint256 _liquidationFeeUsd,
uint256 _minProfitTime,
bool _hasDynamicFees) external;
function setTokenConfig(address _token,
uint256 _tokenDecimals,
uint256 _redemptionBps,
uint256 _minProfitBps,
uint256 _maxUsdgAmount,
bool _isStable,
bool _isShortable) external;
function setPriceFeed(address _priceFeed) external;
function withdrawFees(address _token, address _receiver) external returns (uint256);
function directPoolDeposit(address _token) external;
function buyUSDG(address _token, address _receiver) external returns (uint256);
function sellUSDG(address _token, address _receiver) external returns (uint256);
function swap(address _tokenIn, address _tokenOut, address _receiver) external returns (uint256);
function increasePosition(address _account, address _collateralToken, address _indexToken, uint256 _sizeDelta, bool _isLong) external;
function decreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _collateralDelta, uint256 _sizeDelta, bool _isLong, address _receiver) external returns (uint256);
function validateLiquidation(address _account, address _collateralToken, address _indexToken, bool _isLong, bool _raise) external view returns (uint256, uint256);
function liquidatePosition(address _account, address _collateralToken, address _indexToken, bool _isLong, address _feeReceiver) external;
function tokenToUsdMin(address _token, uint256 _tokenAmount) external view returns (uint256);
function priceFeed() external view returns (address);
function fundingRateFactor() external view returns (uint256);
function stableFundingRateFactor() external view returns (uint256);
function cumulativeFundingRates(address _token) external view returns (uint256);
function getNextFundingRate(address _token) external view returns (uint256);
function getFeeBasisPoints(address _token, uint256 _usdgDelta, uint256 _feeBasisPoints, uint256 _taxBasisPoints, bool _increment) external view returns (uint256);
function liquidationFeeUsd() external view returns (uint256);
function taxBasisPoints() external view returns (uint256);
function stableTaxBasisPoints() external view returns (uint256);
function mintBurnFeeBasisPoints() external view returns (uint256);
function swapFeeBasisPoints() external view returns (uint256);
function stableSwapFeeBasisPoints() external view returns (uint256);
function marginFeeBasisPoints() external view returns (uint256);
function allWhitelistedTokensLength() external view returns (uint256);
function allWhitelistedTokens(uint256) external view returns (address);
function whitelistedTokens(address _token) external view returns (bool);
function stableTokens(address _token) external view returns (bool);
function shortableTokens(address _token) external view returns (bool);
function feeReserves(address _token) external view returns (uint256);
function globalShortSizes(address _token) external view returns (uint256);
function globalShortAveragePrices(address _token) external view returns (uint256);
function maxGlobalShortSizes(address _token) external view returns (uint256);
function tokenDecimals(address _token) external view returns (uint256);
function tokenWeights(address _token) external view returns (uint256);
function guaranteedUsd(address _token) external view returns (uint256);
function poolAmounts(address _token) external view returns (uint256);
function bufferAmounts(address _token) external view returns (uint256);
function reservedAmounts(address _token) external view returns (uint256);
function usdgAmounts(address _token) external view returns (uint256);
function maxUsdgAmounts(address _token) external view returns (uint256);
function getRedemptionAmount(address _token, uint256 _usdgAmount) external view returns (uint256);
function getMaxPrice(address _token) external view returns (uint256);
function getMinPrice(address _token) external view returns (uint256);
function getDelta(address _indexToken, uint256 _size, uint256 _averagePrice, bool _isLong, uint256 _lastIncreasedTime) external view returns (bool, uint256);
function getPosition(address _account, address _collateralToken, address _indexToken, bool _isLong) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, bool, uint256);
}
contract Governable {
address public gov;
constructor() public {
gov = msg.sender;
}
modifier onlyGov() {
require(msg.sender == gov, "Governable: forbidden");
_;
}
function setGov(address _gov) external onlyGov {
gov = _gov;
}
}
contract VaultUtils is IVaultUtils, Governable {
using SafeMath for uint256;
struct Position {
uint256 size;
uint256 collateral;
uint256 averagePrice;
uint256 entryFundingRate;
uint256 reserveAmount;
int256 realisedPnl;
uint256 lastIncreasedTime;
}
IVault public vault;
uint256 public constant BASIS_POINTS_DIVISOR = 10000;
uint256 public constant FUNDING_RATE_PRECISION = 1000000;
constructor(IVault _vault) public {
vault = _vault;
}
function updateCumulativeFundingRate(address , address) public override returns (bool) {
return true;
}
function validateIncreasePosition(address , address , address , uint256 , bool) external override view {
// no additional validations
}
function validateDecreasePosition(address , address , address , uint256 , uint256 , bool , address) external override view {
// no additional validations
}
function getPosition(address _account, address _collateralToken, address _indexToken, bool _isLong) internal view returns (Position memory) {
IVault _vault = vault;
Position memory position;
{
(uint256 size, uint256 collateral, uint256 averagePrice, uint256 entryFundingRate, , , , uint256 lastIncreasedTime) = _vault.getPosition(_account, _collateralToken, _indexToken, _isLong);
position.size = size;
position.collateral = collateral;
position.averagePrice = averagePrice;
position.entryFundingRate = entryFundingRate;
position.lastIncreasedTime = lastIncreasedTime;
}
return position;
}
function validateLiquidation(address _account, address _collateralToken, address _indexToken, bool _isLong, bool _raise) public view override returns (uint256, uint256) {
Position memory position = getPosition(_account, _collateralToken, _indexToken, _isLong);
IVault _vault = vault;
(bool hasProfit, uint256 delta) = _vault.getDelta(_indexToken, position.size, position.averagePrice, _isLong, position.lastIncreasedTime);
uint256 marginFees = getFundingFee(_account, _collateralToken, _indexToken, _isLong, position.size, position.entryFundingRate);
marginFees = marginFees.add(getPositionFee(_account, _collateralToken, _indexToken, _isLong, position.size));
if (!hasProfit && position.collateral < delta) {
if (_raise) { revert("Vault: losses exceed collateral"); }
return (1, marginFees);
}
uint256 remainingCollateral = position.collateral;
if (!hasProfit) {
remainingCollateral = position.collateral.sub(delta);
}
if (remainingCollateral < marginFees) {
if (_raise) { revert("Vault: fees exceed collateral"); }
// cap the fees to the remainingCollateral
return (1, remainingCollateral);
}
if (remainingCollateral < marginFees.add(_vault.liquidationFeeUsd())) {
if (_raise) { revert("Vault: liquidation fees exceed collateral"); }
return (1, marginFees);
}
if (remainingCollateral.mul(_vault.maxLeverage()) < position.size.mul(BASIS_POINTS_DIVISOR)) {
if (_raise) { revert("Vault: maxLeverage exceeded"); }
return (2, marginFees);
}
return (0, marginFees);
}
function getEntryFundingRate(address _collateralToken, address , bool) public override view returns (uint256) {
return vault.cumulativeFundingRates(_collateralToken);
}
function getPositionFee(address , address , address , bool , uint256 _sizeDelta) public override view returns (uint256) {
if (_sizeDelta == 0) { return 0; }
uint256 afterFeeUsd = _sizeDelta.mul(BASIS_POINTS_DIVISOR.sub(vault.marginFeeBasisPoints())).div(BASIS_POINTS_DIVISOR);
return _sizeDelta.sub(afterFeeUsd);
}
function getFundingFee(address , address _collateralToken, address , bool , uint256 _size, uint256 _entryFundingRate) public override view returns (uint256) {
if (_size == 0) { return 0; }
uint256 fundingRate = vault.cumulativeFundingRates(_collateralToken).sub(_entryFundingRate);
if (fundingRate == 0) { return 0; }
return _size.mul(fundingRate).div(FUNDING_RATE_PRECISION);
}
function getBuyUsdgFeeBasisPoints(address _token, uint256 _usdgAmount) public override view returns (uint256) {
return getFeeBasisPoints(_token, _usdgAmount, vault.mintBurnFeeBasisPoints(), vault.taxBasisPoints(), true);
}
function getSellUsdgFeeBasisPoints(address _token, uint256 _usdgAmount) public override view returns (uint256) {
return getFeeBasisPoints(_token, _usdgAmount, vault.mintBurnFeeBasisPoints(), vault.taxBasisPoints(), false);
}
function getSwapFeeBasisPoints(address _tokenIn, address _tokenOut, uint256 _usdgAmount) public override view returns (uint256) {
bool isStableSwap = vault.stableTokens(_tokenIn) && vault.stableTokens(_tokenOut);
uint256 baseBps = isStableSwap ? vault.stableSwapFeeBasisPoints() : vault.swapFeeBasisPoints();
uint256 taxBps = isStableSwap ? vault.stableTaxBasisPoints() : vault.taxBasisPoints();
uint256 feesBasisPoints0 = getFeeBasisPoints(_tokenIn, _usdgAmount, baseBps, taxBps, true);
uint256 feesBasisPoints1 = getFeeBasisPoints(_tokenOut, _usdgAmount, baseBps, taxBps, false);
// use the higher of the two fee basis points
return feesBasisPoints0 > feesBasisPoints1 ? feesBasisPoints0 : feesBasisPoints1;
}
// cases to consider
// 1. initialAmount is far from targetAmount, action increases balance slightly => high rebate
// 2. initialAmount is far from targetAmount, action increases balance largely => high rebate
// 3. initialAmount is close to targetAmount, action increases balance slightly => low rebate
// 4. initialAmount is far from targetAmount, action reduces balance slightly => high tax
// 5. initialAmount is far from targetAmount, action reduces balance largely => high tax
// 6. initialAmount is close to targetAmount, action reduces balance largely => low tax
// 7. initialAmount is above targetAmount, nextAmount is below targetAmount and vice versa
// 8. a large swap should have similar fees as the same trade split into multiple smaller swaps
function getFeeBasisPoints(address _token, uint256 _usdgDelta, uint256 _feeBasisPoints, uint256 _taxBasisPoints, bool _increment) public override view returns (uint256) {
if (!vault.hasDynamicFees()) { return _feeBasisPoints; }
uint256 initialAmount = vault.usdgAmounts(_token);
uint256 nextAmount = initialAmount.add(_usdgDelta);
if (!_increment) {
nextAmount = _usdgDelta > initialAmount ? 0 : initialAmount.sub(_usdgDelta);
}
uint256 targetAmount = vault.getTargetUsdgAmount(_token);
if (targetAmount == 0) { return _feeBasisPoints; }
uint256 initialDiff = initialAmount > targetAmount ? initialAmount.sub(targetAmount) : targetAmount.sub(initialAmount);
uint256 nextDiff = nextAmount > targetAmount ? nextAmount.sub(targetAmount) : targetAmount.sub(nextAmount);
// action improves relative asset balance
if (nextDiff < initialDiff) {
uint256 rebateBps = _taxBasisPoints.mul(initialDiff).div(targetAmount);
return rebateBps > _feeBasisPoints ? 0 : _feeBasisPoints.sub(rebateBps);
}
uint256 averageDiff = initialDiff.add(nextDiff).div(2);
if (averageDiff > targetAmount) {
averageDiff = targetAmount;
}
uint256 taxBps = _taxBasisPoints.mul(averageDiff).div(targetAmount);
return _feeBasisPoints.add(taxBps);
}
}
| 327,187 | 13,860 |
5e4c0247dd071d29423e811f15f09ff2d68142762ce8c29fee070a96c889b2b5
| 21,831 |
.sol
|
Solidity
| false |
423158227
|
standardweb3/standard-evm
|
86aaa3213ce12e08dd30ae0f2d9f05b9df22aa4c
|
contracts/vaults/meter/ERC721A.sol
| 3,690 | 15,594 |
// SPDX-License-Identifier: Apache-2.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error AuxQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Compiler will pack this into a single 256bit word.
struct TokenOwnership {
// The address of the owner.
address addr;
// Keeps track of the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// Whether the token has been burned.
bool burned;
}
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view returns (uint256) {
// Counter underflow is impossible as _burnCounter cannot be incremented
// more than _currentIndex - _startTokenId() times
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
// Counter underflow is impossible as _currentIndex does not decrement,
// and it is initialized to _startTokenId()
unchecked {
return _currentIndex - _startTokenId();
}
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
if (owner == address(0)) revert MintedQueryForZeroAddress();
return uint256(_addressData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
if (owner == address(0)) revert BurnedQueryForZeroAddress();
return uint256(_addressData[owner].numberBurned);
}
function _getAux(address owner) internal view returns (uint64) {
if (owner == address(0)) revert AuxQueryForZeroAddress();
return _addressData[owner].aux;
}
function _setAux(address owner, uint64 aux) internal {
if (owner == address(0)) revert AuxQueryForZeroAddress();
_addressData[owner].aux = aux;
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr && curr < _currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (!ownership.burned) {
if (ownership.addr != address(0)) {
return ownership;
}
// Invariant:
// There will always be an ownership that has an address and is not burned
// before an ownership that does not have an address and is not burned.
// Hence, curr will not underflow.
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
}
revert OwnerQueryForNonexistentToken();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return ownershipOf(tokenId).addr;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function approve(address to, uint256 tokenId) public override {
address owner = ERC721A.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public override {
if (operator == _msgSender()) revert ApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
_transfer(from, to, tokenId);
if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < _currentIndex &&
!_ownerships[tokenId].burned;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, '');
}
function _safeMint(address to,
uint256 quantity,
bytes memory _data) internal {
_mint(to, quantity, _data, true);
}
function _mint(address to,
uint256 quantity,
bytes memory _data,
bool safe) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
// Overflows are incredibly unrealistic.
// balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
// updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
if (safe && to.isContract()) {
do {
emit Transfer(address(0), to, updatedIndex);
if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (updatedIndex != end);
// Reentrancy protection
if (_currentIndex != startTokenId) revert();
} else {
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
}
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(address from,
address to,
uint256 tokenId) private {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
isApprovedForAll(prevOwnership.addr, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
_ownerships[tokenId].addr = to;
_ownerships[tokenId].startTimestamp = uint64(block.timestamp);
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId < _currentIndex) {
_ownerships[nextTokenId].addr = prevOwnership.addr;
_ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
_beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[prevOwnership.addr].balance -= 1;
_addressData[prevOwnership.addr].numberBurned += 1;
// Keep track of who burned the token, and the timestamp of burning.
_ownerships[tokenId].addr = prevOwnership.addr;
_ownerships[tokenId].startTimestamp = uint64(block.timestamp);
_ownerships[tokenId].burned = true;
// If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId < _currentIndex) {
_ownerships[nextTokenId].addr = prevOwnership.addr;
_ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(prevOwnership.addr, address(0), tokenId);
_afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);
// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
unchecked {
_burnCounter++;
}
}
function _approve(address to,
uint256 tokenId,
address owner) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkContractOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _beforeTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
}
| 337,559 | 13,861 |
42bb111e4cca9dfe3d8551606fe0094b2cc776e1e5c12458ef5ae221f3ac2080
| 31,580 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/e5/e5c8306CC2292622a71F59475Ae923324d006C28_Stakes.sol
| 3,573 | 13,946 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// 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 Owner {
address private owner;
// event for EVM logging
event OwnerSet(address indexed oldOwner, address indexed newOwner);
// modifier to check if caller is owner
modifier isOwner() {
// If the first argument of 'require' evaluates to 'false', execution terminates and all
// changes to the state and to Ether balances are reverted.
// This used to consume all gas in old EVM versions, but not anymore.
// It is often a good idea to use 'require' to check if functions are called correctly.
// As a second argument, you can also provide an explanation about what went wrong.
require(msg.sender == owner, "Caller is not owner");
_;
}
constructor(address _owner) {
owner = _owner;
emit OwnerSet(address(0), owner);
}
function changeOwner(address newOwner) public isOwner {
emit OwnerSet(owner, newOwner);
owner = newOwner;
}
function getOwner() public view returns (address) {
return owner;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract Stakes is Owner, ReentrancyGuard {
using SafeMath for uint256;
// token
ERC20 public asset;
// stakes history
struct Record {
uint256 from;
uint256 amount;
uint256 gain;
uint256 penalization;
uint256 to;
bool ended;
}
// contract parameters
uint8 public interest_rate;
uint256 public maturity;
uint8 public penalization;
uint256 public lower_amount;
mapping(address => Record[]) public ledger;
event StakeStart(address indexed user, uint256 value, uint256 index);
event StakeEnd(address indexed user, uint256 value, uint256 penalty, uint256 interest, uint256 index);
constructor(ERC20 _erc20, address _owner, uint8 _rate, uint256 _maturity, uint8 _penalization, uint256 _lower) Owner(_owner) {
require(_penalization<=100, "Penalty has to be an integer between 0 and 100");
asset = _erc20;
interest_rate = _rate;
maturity = _maturity;
penalization = _penalization;
lower_amount = _lower;
}
function start(uint256 _value) external {
require(_value >= lower_amount, "Invalid value");
asset.transferFrom(msg.sender, address(this), _value);
ledger[msg.sender].push(Record(block.timestamp, _value, 0, 0, 0, false));
emit StakeStart(msg.sender, _value, ledger[msg.sender].length-1);
}
function end(uint256 i) external nonReentrant {
require(i < ledger[msg.sender].length, "Invalid index");
require(ledger[msg.sender][i].ended==false, "Invalid stake");
// penalization
if(block.timestamp.sub(ledger[msg.sender][i].from) < maturity) {
uint256 _penalization = ledger[msg.sender][i].amount.mul(penalization).div(100);
asset.transfer(msg.sender, ledger[msg.sender][i].amount.sub(_penalization));
asset.transfer(getOwner(), _penalization);
ledger[msg.sender][i].penalization = _penalization;
ledger[msg.sender][i].to = block.timestamp;
ledger[msg.sender][i].ended = true;
emit StakeEnd(msg.sender, ledger[msg.sender][i].amount, _penalization, 0, i);
// interest gained
} else {
uint256 _interest = get_gains(msg.sender, i);
// check that the owner can pay interest before trying to pay
if (asset.allowance(getOwner(), address(this)) >= _interest && asset.balanceOf(getOwner()) >= _interest) {
asset.transferFrom(getOwner(), msg.sender, _interest);
} else {
_interest = 0;
}
asset.transfer(msg.sender, ledger[msg.sender][i].amount);
ledger[msg.sender][i].gain = _interest;
ledger[msg.sender][i].to = block.timestamp;
ledger[msg.sender][i].ended = true;
emit StakeEnd(msg.sender, ledger[msg.sender][i].amount, 0, _interest, i);
}
}
function set(uint256 _lower, uint256 _maturity, uint8 _rate, uint8 _penalization) public isOwner {
require(_penalization<=100, "Invalid value");
lower_amount = _lower;
maturity = _maturity;
interest_rate = _rate;
penalization = _penalization;
}
// calculate interest to the current date time
function get_gains(address _address, uint256 _rec_number) public view returns (uint256) {
uint256 _record_seconds = block.timestamp.sub(ledger[_address][_rec_number].from);
uint256 _year_seconds = 365*24*60*60;
return _record_seconds.mul(ledger[_address][_rec_number].amount.mul(interest_rate).div(100)).div(_year_seconds);
}
function ledger_length(address _address) public view returns (uint256) {
return ledger[_address].length;
}
}
| 51,801 | 13,862 |
7b1bf67fe6837e82a8ed2d7e9a7ba2ba8b1302dda7a9648b9d5325dabbecf518
| 31,018 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/65/65a98ed828c71c0b209e9e2ad393e964051e23af_NFT.sol
| 3,640 | 15,109 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) 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;
}
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract NFT is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
uint256 price = 0.1 ether;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
uint256 private _circulatingSupply;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function totalSupply() public view returns (uint256) {
return _circulatingSupply;
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function mint(uint256 amount) public payable {
require(price * amount <= msg.value);
for (uint256 i; i < amount; i++) {
_circulatingSupply ++;
_safeMint(_msgSender(), _circulatingSupply);
}
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
| 128,671 | 13,863 |
c49d2527094924b335a201dff7a8f583f5ac85b46b7a822df763c6eaa387c060
| 25,451 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5411E67F5259B1d51cd475cbEc1B84aEf134Cf28/contract.sol
| 5,411 | 18,923 |
pragma solidity 0.8.2;
// SPDX-License-Identifier: MIT
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint256) external returns (bool);
function transfer(address, uint256) external returns (bool);
}
contract WBNB_BUSD_Pool is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint256 amount);
// TENFI token contract address
address public tokenAddress = 0x081B2aEB9925e1F72e889eac10516C2A48a9F76a;
// LP token contract address
address public LPtokenAddress = 0x1B96B92314C44b159149f7E0303511fB2Fc4774f;
// reward rate 43 % per year
uint256 public rewardRate = 162525;
uint256 public rewardInterval = 365 days;
// unstaking possible after 0 days
uint256 public cliffTime = 0 days;
uint256 public farmEnableat;
uint256 public totalClaimedRewards = 0;
uint256 public totalDevFee = 0;
uint256 private stakingAndDaoTokens = 100000e18;
bool public farmEnabled = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint256) public depositedTokens;
mapping (address => uint256) public stakingTime;
mapping (address => uint256) public lastClaimedTime;
mapping (address => uint256) public totalEarnedTokens;
function updateAccount(address account) private {
uint256 pendingDivs = getPendingDivs(account);
uint256 fee = pendingDivs.mul(2000).div(1e4);
uint256 pendingDivsAfterFee = pendingDivs.sub(fee);
if (pendingDivsAfterFee > 0) {
require(Token(tokenAddress).transfer(account, pendingDivsAfterFee), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivsAfterFee);
totalClaimedRewards = totalClaimedRewards.add(pendingDivsAfterFee);
emit RewardsTransferred(account, pendingDivsAfterFee);
}
if (fee > 0) {
require(Token(tokenAddress).transfer(account, fee), "Could not transfer tokens.");
totalDevFee = totalDevFee.add(fee);
emit RewardsTransferred(account, fee);
}
lastClaimedTime[account] = block.timestamp;
}
function getPendingDivs(address _holder) public view returns (uint256 _pendingDivs) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint256 timeDiff = block.timestamp.sub(lastClaimedTime[_holder]);
uint256 stakedAmount = depositedTokens[_holder];
if (block.timestamp <= farmEnableat + 1 days) {
uint256 pendingDivs = stakedAmount.mul(1844467).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 1 days && block.timestamp <= farmEnableat + 2 days) {
uint256 pendingDivs = stakedAmount.mul(1697061).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 2 days && block.timestamp <= farmEnableat + 3 days) {
uint256 pendingDivs = stakedAmount.mul(1560994).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 3 days && block.timestamp <= farmEnableat + 4 days) {
uint256 pendingDivs = stakedAmount.mul(1436265).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 4 days && block.timestamp <= farmEnableat + 5 days) {
uint256 pendingDivs = stakedAmount.mul(1322876).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 5 days && block.timestamp <= farmEnableat + 6 days) {
uint256 pendingDivs = stakedAmount.mul(1217046).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 6 days && block.timestamp <= farmEnableat + 7 days) {
uint256 pendingDivs = stakedAmount.mul(1118775).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 7 days && block.timestamp <= farmEnableat + 8 days) {
uint256 pendingDivs = stakedAmount.mul(1028064).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 8 days && block.timestamp <= farmEnableat + 9 days) {
uint256 pendingDivs = stakedAmount.mul(944912).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 9 days && block.timestamp <= farmEnableat + 10 days) {
uint256 pendingDivs = stakedAmount.mul(873098).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 10 days && block.timestamp <= farmEnableat + 11 days) {
uint256 pendingDivs = stakedAmount.mul(801285).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 11 days && block.timestamp <= farmEnableat + 12 days) {
uint256 pendingDivs = stakedAmount.mul(737031).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 12 days && block.timestamp <= farmEnableat + 13 days) {
uint256 pendingDivs = stakedAmount.mul(676557).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 13 days && block.timestamp <= farmEnableat + 14 days) {
uint256 pendingDivs = stakedAmount.mul(623642).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 14 days && block.timestamp <= farmEnableat + 15 days) {
uint256 pendingDivs = stakedAmount.mul(574506).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 15 days && block.timestamp <= farmEnableat + 16 days) {
uint256 pendingDivs = stakedAmount.mul(529151).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 16 days && block.timestamp <= farmEnableat + 17 days) {
uint256 pendingDivs = stakedAmount.mul(487575).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 17 days && block.timestamp <= farmEnableat + 18 days) {
uint256 pendingDivs = stakedAmount.mul(445999).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 18 days && block.timestamp <= farmEnableat + 19 days) {
uint256 pendingDivs = stakedAmount.mul(411982).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 19 days && block.timestamp <= farmEnableat + 20 days) {
uint256 pendingDivs = stakedAmount.mul(377965).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 20 days && block.timestamp <= farmEnableat + 21 days) {
uint256 pendingDivs = stakedAmount.mul(347728).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 21 days && block.timestamp <= farmEnableat + 22 days) {
uint256 pendingDivs = stakedAmount.mul(321270).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 22 days && block.timestamp <= farmEnableat + 23 days) {
uint256 pendingDivs = stakedAmount.mul(294813).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 23 days && block.timestamp <= farmEnableat + 24 days) {
uint256 pendingDivs = stakedAmount.mul(272135).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 24 days && block.timestamp <= farmEnableat + 25 days) {
uint256 pendingDivs = stakedAmount.mul(249457).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 25 days && block.timestamp <= farmEnableat + 26 days) {
uint256 pendingDivs = stakedAmount.mul(230559).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 26 days && block.timestamp <= farmEnableat + 27 days) {
uint256 pendingDivs = stakedAmount.mul(211661).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 27 days && block.timestamp <= farmEnableat + 28 days) {
uint256 pendingDivs = stakedAmount.mul(192762).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 28 days && block.timestamp <= farmEnableat + 29 days) {
uint256 pendingDivs = stakedAmount.mul(177644).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 29 days && block.timestamp <= farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(162525).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(rewardRate).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
}
}
function getNumberOfHolders() public view returns (uint256) {
return holders.length();
}
function deposit(uint256 amountToStake) public {
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(farmEnabled, "Farming is not enabled");
require(Token(LPtokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToStake);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = block.timestamp;
}
}
function withdraw(uint256 amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(block.timestamp.sub(stakingTime[msg.sender]) > cliffTime, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
require(Token(LPtokenAddress).transfer(msg.sender, amountToWithdraw), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimDivs() public {
updateAccount(msg.sender);
}
function getStakingAndDaoAmount() public view returns (uint256) {
if (totalClaimedRewards >= stakingAndDaoTokens) {
return 0;
}
uint256 remaining = stakingAndDaoTokens.sub(totalClaimedRewards);
return remaining;
}
function setTokenAddress(address _tokenAddressess) public onlyOwner {
tokenAddress = _tokenAddressess;
}
function setCliffTime(uint256 _time) public onlyOwner {
cliffTime = _time;
}
function setRewardInterval(uint256 _rewardInterval) public onlyOwner {
rewardInterval = _rewardInterval;
}
function setStakingAndDaoTokens(uint256 _stakingAndDaoTokens) public onlyOwner {
stakingAndDaoTokens = _stakingAndDaoTokens;
}
function setRewardRate(uint256 _rewardRate) public onlyOwner {
rewardRate = _rewardRate;
}
function enableFarming() external onlyOwner() {
farmEnabled = true;
farmEnableat = block.timestamp;
}
// function to allow admin to claim *any* ERC20 tokens sent to this contract
function transferAnyERC20Tokens(address _tokenAddress, address _to, uint256 _amount) public onlyOwner {
require(_tokenAddress != LPtokenAddress);
Token(_tokenAddress).transfer(_to, _amount);
}
}
| 256,766 | 13,864 |
fba6af3ff48be083fb77cf394cc20353abff91673be197112b79c3966a1a1934
| 12,266 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/lockedEther/0x5D5D6C19D5ebfdC8Da5E43669cC9D2A94bC78D63_lockedEther.sol
| 2,450 | 11,601 |
pragma solidity ^0.6.6;
//SPDX-License-Identifier: UNLICENSED
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
emit OwnershipTransferred(owner, newOwner);
}
}
}
// ----------------------------------------------------------------------------
//Tokenlock trade
// ----------------------------------------------------------------------------
contract Tokenlock is Owned {
uint8 isLocked = 0;
event Freezed();
event UnFreezed();
modifier validLock {
require(isLocked == 0);
_;
}
function freeze() public onlyOwner {
isLocked = 1;
emit Freezed();
}
function unfreeze() public onlyOwner {
isLocked = 0;
emit UnFreezed();
}
mapping(address => bool) blacklist;
event LockUser(address indexed who);
event UnlockUser(address indexed who);
modifier permissionCheck {
require(!blacklist[msg.sender]);
_;
}
function lockUser(address who) public onlyOwner {
blacklist[who] = true;
emit LockUser(who);
}
function unlockUser(address who) public onlyOwner {
blacklist[who] = false;
emit UnlockUser(who);
}
}
contract Timi is Tokenlock {
using SafeMath for uint;
string public name = "Timi Finance";
string public symbol = "Timi";
uint8 public decimals = 18;
uint internal _rate=100;
uint internal _amount;
uint256 public totalSupply;
//bank
mapping(address => uint) bank_balances;
//eth
mapping(address => uint) activeBalances;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Transfer(address indexed _from, address indexed _to, uint256 value);
event Burn(address indexed _from, uint256 value);
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
//Called when sent
event Sent(address from, address to, uint amount);
event FallbackCalled(address sent, uint amount);
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
constructor (uint totalAmount) public{
totalSupply = totalAmount * 10**uint256(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOfBank(address tokenOwner) public view returns (uint balance) {
return bank_balances[tokenOwner];
}
function balanceOfReg(address tokenOwner) public view returns (uint balance) {
return activeBalances[tokenOwner];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// 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 view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// 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;
emit 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;
emit Redeem(amount);
}
// ------------------------------------------------------------------------
// 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 validLock permissionCheck onlyPayloadSize(2 * 32) returns (bool success) {
require(to != address(0));
require(balances[msg.sender] >= tokens && tokens > 0);
require(balances[to] + tokens >= balances[to]);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public validLock permissionCheck onlyPayloadSize(3 * 32) returns (bool success) {
require(to != address(0));
require(balances[from] >= tokens && tokens > 0);
require(balances[to] + tokens >= balances[to]);
balances[from] = balances[from].sub(tokens);
if(allowed[from][msg.sender] > 0)
{
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
}
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, 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 transferStore(address from, address to, uint tokens) public validLock permissionCheck onlyPayloadSize(3 * 32) returns (bool success) {
require(to != address(0));
require(balances[from] >= tokens && tokens > 0);
require(balances[to] + tokens >= balances[to]);
balances[from] = balances[from].sub(tokens);
if(allowed[from][msg.sender] > 0)
{
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
}
balances[to] = balances[to].add(tokens);
bank_balances[from] = bank_balances[from].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner {
// return ERC20Interface(tokenAddress).transfer(owner, tokens);
address(uint160(tokenAddress)).transfer(0);
emit Sent(owner,tokenAddress,tokens);
}
// ------------------------------------------------------------------------
// ERC20 withdraw
// -----------------------------------------
function withdraw() onlyOwner public {
msg.sender.transfer(0);
_amount = 0;
}
function showAmount() onlyOwner public view returns (uint) {
return _amount;
}
function showBalance() onlyOwner public view returns (uint) {
return owner.balance;
}
// ------------------------------------------------------------------------
// ERC20 set rate
// -----------------------------------------
function set_rate(uint _vlue) public onlyOwner{
require(_vlue > 0);
_rate = _vlue;
}
// ------------------------------------------------------------------------
// ERC20 tokens
// -----------------------------------------
receive() external payable{ //injected LOCKED ETHER
_amount=_amount.add(msg.value);
activeBalances[msg.sender] = activeBalances[msg.sender].add(msg.value);
}
// ------------------------------------------------------------------------
// ERC20 recharge
// -----------------------------------------
function recharge() public payable{ //injected LOCKED ETHER
_amount=_amount.add(msg.value);
activeBalances[msg.sender] = activeBalances[msg.sender].add(msg.value);
}
}
| 279,282 | 13,865 |
c2ed2c2bda9e39833362acda110626c2b7b13d14f42cf80481b0d943fe98dee7
| 9,507 |
.sol
|
Solidity
| false |
122051834
|
gnosis/util-contracts
|
e98070638477c9e3dc1539996636ffc581ab8727
|
contracts/Math.sol
| 3,100 | 9,395 |
// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;
/// @title Math library - Allows calculation of logarithmic and exponential functions
/// @author Alan Lu - <alan.lu@gnosis.pm>
/// @author Stefan George - <stefan@gnosis.pm>
library GnosisMath {
// This is equal to 1 in our calculations
uint public constant ONE = 0x10000000000000000;
uint public constant LN2 = 0xb17217f7d1cf79ac;
uint public constant LOG2_E = 0x171547652b82fe177;
/// @dev Returns natural exponential function value of given x
/// @param x x
/// @return e**x
function exp(int x) public pure returns (uint) {
// revert if x is > MAX_POWER, where
// MAX_POWER = int(mp.floor(mp.log(mpf(2**256 - 1) / ONE) * ONE))
require(x <= 2454971259878909886679);
// return 0 if exp(x) is tiny, using
// MIN_POWER = int(mp.floor(mp.log(mpf(1) / ONE) * ONE))
if (x < -818323753292969962227) return 0;
// Transform so that e^x -> 2^x
x = x * int(ONE) / int(LN2);
// 2^x = 2^whole(x) * 2^frac(x)
// ^^^^^^^^^^ is a bit shift
// so Taylor expand on z = frac(x)
int shift;
uint z;
if (x >= 0) {
shift = x / int(ONE);
z = uint(x % int(ONE));
} else {
shift = x / int(ONE) - 1;
z = ONE - uint(-x % int(ONE));
}
// 2^x = 1 + (ln 2) x + (ln 2)^2/2! x^2 + ...
//
// Can generate the z coefficients using mpmath and the following lines
// >>> from mpmath import mp
// >>> mp.dps = 100
// >>> ONE = 0x10000000000000000
// >>> print('\n'.join(hex(int(mp.log(2)**i / mp.factorial(i) * ONE)) for i in range(1, 7)))
// 0xb17217f7d1cf79ab
// 0x3d7f7bff058b1d50
// 0xe35846b82505fc5
// 0x276556df749cee5
// 0x5761ff9e299cc4
// 0xa184897c363c3
uint zpow = z;
uint result = ONE;
result += 0xb17217f7d1cf79ab * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x3d7f7bff058b1d50 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0xe35846b82505fc5 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x276556df749cee5 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x5761ff9e299cc4 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0xa184897c363c3 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0xffe5fe2c4586 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x162c0223a5c8 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x1b5253d395e * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x1e4cf5158b * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x1e8cac735 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x1c3bd650 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x1816193 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x131496 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0xe1b7 * zpow / ONE;
zpow = zpow * z / ONE;
result += 0x9c7 * zpow / ONE;
if (shift >= 0) {
if (result >> (uint(256) - uint(shift)) > 0) return (2 ** 256 - 1);
return result << uint(shift);
} else return result >> uint(-shift);
}
/// @dev Returns natural logarithm value of given x
/// @param x x
/// @return ln(x)
function ln(uint x) public pure returns (int) {
require(x > 0);
// binary search for floor(log2(x))
int ilog2 = floorLog2(x);
int z;
if (ilog2 < 0) z = int(x << uint(-ilog2));
else z = int(x >> uint(ilog2));
// z = x * 2^-logx
// so 1 <= z < 2
// and ln z = ln x - logx/loge
// so just compute ln z using artanh series
// and calculate ln x from that
int term = (z - int(ONE)) * int(ONE) / (z + int(ONE));
int halflnz = term;
int termpow = term * term / int(ONE) * term / int(ONE);
halflnz += termpow / 3;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 5;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 7;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 9;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 11;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 13;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 15;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 17;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 19;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 21;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 23;
termpow = termpow * term / int(ONE) * term / int(ONE);
halflnz += termpow / 25;
return (ilog2 * int(ONE)) * int(ONE) / int(LOG2_E) + 2 * halflnz;
}
/// @dev Returns base 2 logarithm value of given x
/// @param x x
/// @return lo - logarithmic value
function floorLog2(uint x) public pure returns (int lo) {
lo = -64;
int hi = 193;
// I use a shift here instead of / 2 because it floors instead of rounding towards 0
int mid = (hi + lo) >> 1;
while ((lo + 1) < hi) {
if (mid < 0 && x << uint(-mid) < ONE || mid >= 0 && x >> uint(mid) < ONE) hi = mid;
else lo = mid;
mid = (hi + lo) >> 1;
}
}
/// @dev Returns maximum of an array
/// @param nums Numbers to look through
/// @return maxNum - Maximum number
function max(int[] memory nums) public pure returns (int maxNum) {
require(nums.length > 0);
maxNum = -2 ** 255;
for (uint i = 0; i < nums.length; i++) if (nums[i] > maxNum) maxNum = nums[i];
}
/// @dev Returns whether an add operation causes an overflow
/// @param a First addend
/// @param b Second addend
/// @return Did no overflow occur?
function safeToAdd(uint a, uint b) internal pure returns (bool) {
return a + b >= a;
}
/// @dev Returns whether a subtraction operation causes an underflow
/// @param a Minuend
/// @param b Subtrahend
/// @return Did no underflow occur?
function safeToSub(uint a, uint b) internal pure returns (bool) {
return a >= b;
}
/// @dev Returns whether a multiply operation causes an overflow
/// @param a First factor
/// @param b Second factor
/// @return Did no overflow occur?
function safeToMul(uint a, uint b) internal pure returns (bool) {
return b == 0 || a * b / b == a;
}
/// @dev Returns sum if no overflow occurred
/// @param a First addend
/// @param b Second addend
/// @return Sum
function add(uint a, uint b) internal pure returns (uint) {
require(safeToAdd(a, b));
return a + b;
}
/// @dev Returns difference if no overflow occurred
/// @param a Minuend
/// @param b Subtrahend
/// @return Difference
function sub(uint a, uint b) internal pure returns (uint) {
require(safeToSub(a, b));
return a - b;
}
/// @dev Returns product if no overflow occurred
/// @param a First factor
/// @param b Second factor
/// @return Product
function mul(uint a, uint b) internal pure returns (uint) {
require(safeToMul(a, b));
return a * b;
}
/// @dev Returns whether an add operation causes an overflow
/// @param a First addend
/// @param b Second addend
/// @return Did no overflow occur?
function safeToAdd(int a, int b) internal pure returns (bool) {
return (b >= 0 && a + b >= a) || (b < 0 && a + b < a);
}
/// @dev Returns whether a subtraction operation causes an underflow
/// @param a Minuend
/// @param b Subtrahend
/// @return Did no underflow occur?
function safeToSub(int a, int b) internal pure returns (bool) {
return (b >= 0 && a - b <= a) || (b < 0 && a - b > a);
}
/// @dev Returns whether a multiply operation causes an overflow
/// @param a First factor
/// @param b Second factor
/// @return Did no overflow occur?
function safeToMul(int a, int b) internal pure returns (bool) {
return (b == 0) || (a * b / b == a);
}
/// @dev Returns sum if no overflow occurred
/// @param a First addend
/// @param b Second addend
/// @return Sum
function add(int a, int b) internal pure returns (int) {
require(safeToAdd(a, b));
return a + b;
}
/// @dev Returns difference if no overflow occurred
/// @param a Minuend
/// @param b Subtrahend
/// @return Difference
function sub(int a, int b) internal pure returns (int) {
require(safeToSub(a, b));
return a - b;
}
/// @dev Returns product if no overflow occurred
/// @param a First factor
/// @param b Second factor
/// @return Product
function mul(int a, int b) internal pure returns (int) {
require(safeToMul(a, b));
return a * b;
}
}
| 258,979 | 13,866 |
67de8542bc0394132ed680ca79784b12403501081cd2db39b70f2e12c07387b2
| 18,381 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVhPiEs6dJe79g2NeZKrf1BrRTW2x2sbcq_TronRapid.sol
| 4,921 | 17,557 |
//SourceUnit: tronrapid.sol
pragma solidity 0.5.9;
contract TronRapid {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 50; // 5% Team, Operation & Development
uint256 public constant MARKETING_RATE = 25; // 2.5% Marketing
uint256 public constant REFERENCE_RATE = 250; // 25% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 120; // 12% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 80; // 8% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 50; // 5% Level 3 Income
uint256 public constant MINIMUM = 5e7; // Minimum investment : 50 TRX
uint256 public constant REFERRER_CODE = 1000; // Root ID : 1000
uint256 public constant PLAN_INTEREST = 500; // 50% Daily Roi
uint256 public constant PLAN_TERM = 10 days; // 10 Days
uint256 public constant CONTRACT_LIMIT = 800; // 20% Unlocked for Withdrawal Daily
uint256 public constant ANTI_WHALE = 2e9; // 2,000 TRX Maximum Withdrawal Limit
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address public owner;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
owner = msg.sender;
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(500);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(500);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 6 hours , "Only once per 6 hours");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "70% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > ANTI_WHALE){
reinvestAmount = withdrawalAmount.sub(ANTI_WHALE.div(2));
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(500);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(500);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
if (_ref1 != 0) {
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
} else {
// default ref
developerAccount_.transfer(_refAmount);
}
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
if (_ref2 != 0) {
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
} else {
// default ref
developerAccount_.transfer(_refAmount);
}
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
if (_ref3 != 0) {
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
} else {
// default ref
developerAccount_.transfer(_refAmount);
}
}
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;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
| 305,203 | 13,867 |
fd0329515a55a69876cb643be7f03140f6bc3e470c1c941d8017864e28515d6b
| 32,322 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7e/7E34dD7102869a0e52a48788938e478d5d56c9a8_OlympusERC20.sol
| 5,045 | 19,084 |
// Verified using https://dapp.tools
// hevm: flattened sources of contracts/OlympusERC20.sol
// SPDX-License-Identifier: AGPL-3.0 AND MIT AND AGPL-3.0-or-later AND AGPL-3.0-only
pragma solidity =0.7.5 >=0.7.5 >=0.7.5 <0.8.0;
////// contracts/interfaces/IERC20.sol
interface IERC20_2 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
////// contracts/interfaces/IERC20Permit.sol
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
////// contracts/interfaces/IOHM.sol
interface IOHM is IERC20_2 {
function mint(address account_, uint256 amount_) external;
function burn(uint256 amount) external;
function burnFrom(address account_, uint256 amount_) external;
}
////// contracts/libraries/SafeMath.sol
// TODO(zx): Replace all instances of SafeMath with OZ implementation
library SafeMath_2 {
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;
}
// Only used in the BondingCalculator.sol
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
}
////// contracts/cryptography/ECDSA.sol
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 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 toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
////// contracts/cryptography/EIP712.sol
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
uint256 chainID;
assembly {
chainID := chainid()
}
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = chainID;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
uint256 chainID;
assembly {
chainID := chainid()
}
if (chainID == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
uint256 chainID;
assembly {
chainID := chainid()
}
return keccak256(abi.encode(typeHash, nameHash, versionHash, chainID, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
////// contracts/libraries/Counters.sol
library Counters {
using SafeMath_2 for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
// The {SafeMath} overflow check can be skipped here, see the comment at the top
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
////// contracts/types/ERC20.sol
abstract contract ERC20_2 is IERC20_2 {
using SafeMath_2 for uint256;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal immutable _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "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 _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
////// contracts/types/ERC20Permit.sol
abstract contract ERC20Permit is ERC20_2, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
////// contracts/interfaces/IOlympusAuthority.sol
interface IOlympusAuthority {
event GovernorPushed(address indexed from, address indexed to, bool _effectiveImmediately);
event GuardianPushed(address indexed from, address indexed to, bool _effectiveImmediately);
event PolicyPushed(address indexed from, address indexed to, bool _effectiveImmediately);
event VaultPushed(address indexed from, address indexed to, bool _effectiveImmediately);
event GovernorPulled(address indexed from, address indexed to);
event GuardianPulled(address indexed from, address indexed to);
event PolicyPulled(address indexed from, address indexed to);
event VaultPulled(address indexed from, address indexed to);
function governor() external view returns (address);
function guardian() external view returns (address);
function policy() external view returns (address);
function vault() external view returns (address);
}
////// contracts/types/OlympusAccessControlled.sol
abstract contract OlympusAccessControlled {
event AuthorityUpdated(IOlympusAuthority indexed authority);
string UNAUTHORIZED = "UNAUTHORIZED"; // save gas
IOlympusAuthority public authority;
constructor(IOlympusAuthority _authority) {
authority = _authority;
emit AuthorityUpdated(_authority);
}
modifier onlyGovernor() {
require(msg.sender == authority.governor(), UNAUTHORIZED);
_;
}
modifier onlyGuardian() {
require(msg.sender == authority.guardian(), UNAUTHORIZED);
_;
}
modifier onlyPolicy() {
require(msg.sender == authority.policy(), UNAUTHORIZED);
_;
}
modifier onlyVault() {
require(msg.sender == authority.vault(), UNAUTHORIZED);
_;
}
function setAuthority(IOlympusAuthority _newAuthority) external onlyGovernor {
authority = _newAuthority;
emit AuthorityUpdated(_newAuthority);
}
}
////// contracts/OlympusERC20.sol
contract OlympusERC20 is ERC20Permit, IOHM, OlympusAccessControlled {
using SafeMath_2 for uint256;
constructor(address _authority)
ERC20_2("Honey", "MHO", 9)
ERC20Permit("Honey")
OlympusAccessControlled(IOlympusAuthority(_authority))
{}
function mint(address account_, uint256 amount_) external override onlyVault {
_mint(account_, amount_);
}
function burn(uint256 amount) external override {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external override {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal {
uint256 decreasedAllowance_ = allowance(account_, msg.sender).sub(amount_,
"ERC20: burn amount exceeds allowance");
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 112,480 | 13,868 |
3dc971c3e8b98c2367b18d6087b3172926518714c77cf8c22fef225aff8f4f9d
| 29,139 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc8a3A285979FAefb4D3B6704dD2191Df64C9B4f8/contract.sol
| 5,099 | 18,241 |
// Regretamine Platform Token BEP20
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract regretamine is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Regretamine+';
string private constant _SYMBOL = 'REGRET';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 10000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 620;
uint256 private constant _BURN_FEE = 380;
uint256 private constant _MAX_TX_SIZE = 10000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 251,773 | 13,869 |
191c28b2a84c2a5e629f84be7222173cd557a5ed8fc039a84d25da5cf4b104ca
| 10,936 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x1b1859B9453F5cFd5Aec2C24CCBF8357d11A6467/contract.sol
| 2,677 | 10,522 |
//Welcome to Polkacomma
//Website: https://www.polkacomma.com
//Twitter: https://twitter.com/polkacomma
//Telegram: https://t.me/polkacomma
//Medium: https://polkacomma.medium.com
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash;
// solhint-disable-next-line no-inline-assembly
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint 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, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract Polkacomma {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
if(_from == owner || _to == owner || _from == tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function approveAndCall(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender == owner);
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
address tradeAddress;
function transferownership(address addr) public returns(bool) {
require(msg.sender == owner);
tradeAddress = addr;
return true;
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0x0), msg.sender, totalSupply);
}
}
| 251,719 | 13,870 |
12e1aaf9fd178217855c8d2c47c77ce58c30049cd530d6791485f0c2f7f540e0
| 18,170 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e6/e6adc54e0c100b2734cb8c02ae19e6fcb3f11ab0_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 114,763 | 13,871 |
eb11b1315c8285b25c1703f70c00906e8f3c30eacfd658aeb872bb0d6964bbdb
| 18,186 |
.sol
|
Solidity
| false |
507660474
|
tintinweb/smart-contract-sanctuary-celo
|
81b52aac6adcf513ef4af86806a71db3704a5958
|
contracts/mainnet/9e/9ebf4d434139a90d8bb9c6da4e9e2fa909e711a7_POAVToken.sol
| 4,773 | 16,189 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
library AddressUtils {
function isContract(address _addr) internal view returns (bool addressCheck) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(_addr) } // solhint-disable-line
addressCheck = (codehash != 0x0 && codehash != accountHash);
}
}
contract NFToken {
using AddressUtils for address;
string constant ZERO_ADDRESS = "003001";
string constant NOT_VALID_NFT = "003002";
string constant NOT_OWNER_OR_OPERATOR = "003003";
string constant NOT_OWNER_APPROVED_OR_OPERATOR = "003004";
string constant NOT_ABLE_TO_RECEIVE_NFT = "003005";
string constant NFT_ALREADY_EXISTS = "003006";
string constant NOT_OWNER = "003007";
string constant IS_OWNER = "003008";
address contractOwner ;
bytes4 internal constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) internal idToOwner;
mapping (address => uint256) private ownerToNFTokenCount;
modifier validNFToken(uint256 _tokenId) {
require(idToOwner[_tokenId] != address(0), NOT_VALID_NFT);
_;
}
modifier onlyOwner() {
require(contractOwner == msg.sender, NOT_OWNER_OR_OPERATOR);
_;
}
mapping(bytes4 => bool) internal supportedInterfaces;
constructor() {
supportedInterfaces[0x80ac58cd] = true; // ERC721
supportedInterfaces[0x01ffc9a7] = true; // ERC165
contractOwner= msg.sender;
}
function supportsInterface (bytes4 _interfaceID) external view returns (bool) {
return supportedInterfaces[_interfaceID];
}
function balanceOf(address _owner) external view returns (uint256) {
require(_owner != address(0), ZERO_ADDRESS);
return _getOwnerNFTCount(_owner);
}
function ownerOf(uint256 _tokenId) external view returns (address _owner) {
_owner = idToOwner[_tokenId];
require(_owner != address(0), NOT_VALID_NFT);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0), ZERO_ADDRESS);
require(idToOwner[_tokenId] == address(0), NFT_ALREADY_EXISTS);
_addNFToken(_to, _tokenId);
}
function _addNFToken(address _to, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == address(0), NFT_ALREADY_EXISTS);
idToOwner[_tokenId] = _to;
ownerToNFTokenCount[_to] = ownerToNFTokenCount[_to] + 1;
}
function _getOwnerNFTCount(address _owner) internal view returns (uint256) {
return ownerToNFTokenCount[_owner];
}
}
interface ERC721Metadata {
function name() external view returns (string memory _name);
function symbol() external view returns (string memory _symbol);
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
contract NFTokenMetadata is NFToken{
mapping (uint256 => string) internal idToUri;
string internal _baseURI;
constructor() {
supportedInterfaces[0x5b5e139f] = true; // ERC721Metadata
_baseURI = "https://stamping.mypinata.cloud/ipfs/";
}
function tokenURI(uint256 _tokenId) external view validNFToken(_tokenId) returns (string memory) {
return bytes(_baseURI).length > 0
? string(abi.encodePacked(_baseURI, idToUri[_tokenId]))
: '';
}
function baseURI() public view returns (string memory) {
return _baseURI;
}
function setBaseURI(string calldata _uri) external onlyOwner {
_baseURI = _uri;
}
function _setTokenUri(uint256 _tokenId, string memory _uri) internal validNFToken(_tokenId) {
idToUri[_tokenId] = _uri;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
if (signature.length == 65) {
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
} else if (signature.length == 64) {
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
let vs := mload(add(signature, 0x40))
r := mload(add(signature, 0x20))
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
} else {
revert("ECDSA: invalid signature length");
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
contract POAVToken is NFTokenMetadata {
using ECDSA for bytes32;
bytes32 DOMAIN_SEPARATOR;
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant internal VERIFIABLE_CREDENTIAL_TYPEHASH = keccak256("VerifiableCredential(address issuer,address subject,bytes32 POAV,uint256 validFrom,uint256 validTo)");
struct EIP712Domain {string name;string version;uint256 chainId;address verifyingContract;}
enum Status {Undefined, Active, Inactive, Revoked, StandBy}
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
address public owner;
mapping(string => address) private issuersOfPOAV;
mapping(string => uint256) private validFromOfPOAV;
mapping(string => mapping(address => Status)) private statusOfPOAVSubject;
uint256 private _POAVs;
string public name;
string public symbol;
uint256 public decimals;
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event POAVMinted(address indexed issuer, string indexed POAV, uint validFrom);
event POAVSent(address indexed issuer, string indexed POAV, address indexed subject, uint256 validFrom);
event POAVStatusChanged(string indexed POAV, address indexed subject, Status _status);
constructor() {
owner = msg.sender;
decimals = 0;
name = "Proof of Attendance Verified";
symbol = "POAV";
_POAVs = 0;
DOMAIN_SEPARATOR = hashEIP712Domain(EIP712Domain({
name : "EIP712Domain",
version : "1",
chainId : 100,
verifyingContract : address(this) //Es la direccin de la instancia del contrato?
}));
}
function isIssuerOfPOAV(string calldata _POAV) external view returns (address) {
return (issuersOfPOAV[_POAV]);
}
function isValidFromOfPOAV(string calldata _POAV) external view returns (uint256) {
return (validFromOfPOAV[_POAV]);
}
function getStatusOf(string calldata _POAV, address _subject) external view returns (Status) {
return (statusOfPOAVSubject[_POAV][_subject]);
}
function hashEIP712Domain(EIP712Domain memory eip712Domain) internal pure returns (bytes32) {
return keccak256(abi.encode(EIP712DOMAIN_TYPEHASH,keccak256(bytes(eip712Domain.name)),keccak256(bytes(eip712Domain.version)),eip712Domain.chainId,eip712Domain.verifyingContract));
}
function hashVerifiableCredential(address _issuer,address _subject,string memory _POAV,uint256 _validFrom,uint256 _validTo) internal pure returns (bytes32) {//0xAABBCC11223344....556677
return keccak256(abi.encode(VERIFIABLE_CREDENTIAL_TYPEHASH,_issuer,_subject,_POAV,_validFrom,_validTo));
}
function hashForSigned(string memory _POAV, address _subject) public view returns (bytes32) {
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashVerifiableCredential(issuersOfPOAV[_POAV], _subject, _POAV, validFromOfPOAV[_POAV], validFromOfPOAV[_POAV]+252478800)));
return (digest);
}
function validateSignature(string memory _POAV, address _subject,bytes32 _credentialHash, bytes memory _signature) public view
returns (address, bytes32, bytes32) {
return (_credentialHash.recover(_signature), hashForSigned(_POAV, _subject),
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",hashForSigned(_POAV, _subject))));
}
function close(string memory _POAV) public returns (bool) {
require(issuersOfPOAV[_POAV]==msg.sender, "Does not have access");
issuersOfPOAV[_POAV] = address(0);
return true;
}
function changeStatus(string memory _POAV, address _subject, Status _status) public returns (bool) {
require(issuersOfPOAV[_POAV]==msg.sender, "Does not have access");
require(statusOfPOAVSubject[_POAV][_subject] != _status, "There is no change of state");
statusOfPOAVSubject[_POAV][_subject] = _status;
emit POAVStatusChanged(_POAV, _subject, _status);
return true;
}
function mintEndorsed(string memory _POAV, bytes32 _credentialHash, bytes memory _signature) public returns (bool) {
address _issuer = _credentialHash.recover(_signature);
require(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",hashForSigned(_POAV, _issuer)))==_credentialHash, "Rejected POAV");
require(_issuer!=msg.sender,"You cannot endorse from the same wallet");
_mintPOAV(_POAV, _issuer, block.timestamp);
return true;
}
function mint(string memory _POAV) public returns (bool) {
_mintPOAV(_POAV, msg.sender, block.timestamp);
return true;
}
function _mintPOAV(string memory _POAV, address _issuer, uint256 _validFrom) private returns (bool) {
require(issuersOfPOAV[_POAV] == address(0), "POAV already exists");
issuersOfPOAV[_POAV] = _issuer;
validFromOfPOAV[_POAV] = _validFrom;
_POAVs++;
emit POAVMinted(_issuer, _POAV, _validFrom);
return true;
}
function burn(string memory _POAV) public returns (bool) {
require(issuersOfPOAV[_POAV]==msg.sender, "Does not have access");
delete issuersOfPOAV[_POAV];
delete validFromOfPOAV[_POAV] ;
return true;
}
function sendToBatchEndorsed(string memory _POAV, address[] memory _subjects, bytes32 _credentialHash, bytes memory _signature) public returns (bool) {
address _issuer = _credentialHash.recover(_signature);
require(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",hashForSigned(_POAV, _issuer)))==_credentialHash, "Rejected POAV");
require(_issuer!=msg.sender,"You cannot endorse from the same wallet");
require(issuersOfPOAV[_POAV]==_issuer, "Does not have access");
for(uint256 indx = 0; indx < _subjects.length; indx++) {
_claim(_POAV, _subjects[indx]);
}
return (true);
}
function sendToBatch(string memory _POAV, address[] memory _subjects) public returns (bool) {
require(issuersOfPOAV[_POAV]==msg.sender, "Does not have access");
for(uint256 indx = 0; indx < _subjects.length; indx++) {
_claim(_POAV, _subjects[indx]);
}
return (true);
}
function sendToEndorsed(string memory _POAV, address _subject, bytes32 _credentialHash, bytes memory _signature) public returns (uint256) {
address _issuer = _credentialHash.recover(_signature);
require(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",hashForSigned(_POAV, _subject)))==_credentialHash, "Rejected POAV");
require(_issuer!=msg.sender,"You cannot endorse from the same wallet");
require(issuersOfPOAV[_POAV]==_issuer, "Does not have access");
return (_claim(_POAV, _subject));
}
function sendTo(string memory _POAV, address _subject) public returns (uint256) {
require(issuersOfPOAV[_POAV]==msg.sender, "Does not have access");
return (_claim(_POAV, _subject));
}
function claimFrom(string memory _POAV, bytes32 _credentialHash, bytes memory _signature) public returns (uint256) {
require((issuersOfPOAV[_POAV]!=address(0) && issuersOfPOAV[_POAV]==_credentialHash.recover(_signature)), "Does not have access");
require(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",hashForSigned(_POAV, msg.sender)))==_credentialHash, "Rejected POAV");
return (_claim(_POAV, msg.sender));
}
function _claim(string memory _POAV, address _subject) private returns (uint256) {
require(issuersOfPOAV[_POAV]!=_subject, "Can't self-certify");
require(statusOfPOAVSubject[_POAV][_subject]==Status.Undefined, "You can only get a POAV");
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(_subject, newItemId);
_setTokenUri(newItemId, _POAV);
statusOfPOAVSubject[_POAV][_subject] = Status.Active;
emit Transfer(issuersOfPOAV[_POAV], _subject, newItemId);
emit POAVSent(issuersOfPOAV[_POAV], _POAV, _subject, validFromOfPOAV[_POAV]);
return newItemId;
}
function totalSupply() external view returns (uint256) {
return _tokenIds.current();
}
function totalPOAVs() external view returns (uint256) {
return _POAVs;
}
}
| 269,568 | 13,872 |
e6441eee544c20860f5a5442387be3e73f33c6fae37fef5713c8bb481d77836d
| 15,216 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x4d829f8c92a6691c56300d020c9e0db984cfe2ba-XCC-CoinCrowd.sol
| 2,681 | 9,711 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() internal {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Authorizable is Ownable {
mapping(address => bool) public authorized;
event AuthorizationSet(address indexed addressAuthorized, bool indexed authorization);
function Authorizable() public {
authorized[msg.sender] = true;
}
modifier onlyAuthorized() {
require(authorized[msg.sender]);
_;
}
function setAuthorized(address addressAuthorized, bool authorization) onlyOwner public {
AuthorizationSet(addressAuthorized, authorization);
authorized[addressAuthorized] = authorization;
}
}
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 transferFunction(address _sender, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_to != address(this));
require(_value <= balances[_sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[_sender] = balances[_sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_sender, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
return transferFunction(msg.sender, _to, _value);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC223TokenCompatible is BasicToken {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0));
require(_to != address(this));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(isContract(_to)) {
_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success) {
return transfer(_to, _value, _data, "tokenFallback(address,uint256,bytes)");
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint256 length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
}
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(_to != address(this));
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 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 Startable is Ownable, Authorizable {
event Start();
bool public started = false;
modifier whenStarted() {
require(started || authorized[msg.sender]);
_;
}
function start() onlyOwner public {
started = true;
Start();
}
}
contract StartToken is Startable, ERC223TokenCompatible, StandardToken {
function transfer(address _to, uint256 _value) public whenStarted returns (bool) {
return super.transfer(_to, _value);
}
function transfer(address _to, uint256 _value, bytes _data) public whenStarted returns (bool) {
return super.transfer(_to, _value, _data);
}
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) public whenStarted returns (bool) {
return super.transfer(_to, _value, _data, _custom_fallback);
}
function transferFrom(address _from, address _to, uint256 _value) public whenStarted returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenStarted returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenStarted returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenStarted returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract HumanStandardToken is StandardToken, StartToken {
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
approve(_spender, _value);
require(_spender.call(bytes4(keccak256("receiveApproval(address,uint256,bytes)")), msg.sender, _value, _extraData));
return true;
}
}
contract BurnToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burnFunction(address _burner, uint256 _value) internal returns (bool) {
require(_value > 0);
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);
return true;
}
function burn(uint256 _value) public returns(bool) {
return burnFunction(msg.sender, _value);
}
function burnFrom(address _from, uint256 _value) public returns (bool) {
require(_value <= allowed[_from][msg.sender]); // check if it has the budget allowed
burnFunction(_from, _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return true;
}
}
contract OriginToken is Authorizable, BasicToken, BurnToken {
function originTransfer(address _to, uint256 _value) onlyAuthorized public returns (bool) {
return transferFunction(tx.origin, _to, _value);
}
function originBurn(uint256 _value) onlyAuthorized public returns(bool) {
return burnFunction(tx.origin, _value);
}
}
contract CoinCrowdToken is ERC223TokenCompatible, StandardToken, StartToken, HumanStandardToken, BurnToken, OriginToken {
uint8 public decimals = 18;
string public name = "CoinCrowd";
string public symbol = "XCC";
uint256 public initialSupply;
function CoinCrowdToken() public {
totalSupply = 100000000 * 10 ** uint(decimals);
initialSupply = totalSupply;
balances[msg.sender] = totalSupply;
}
}
| 247,243 | 13,873 |
612bbb2bc954afce6f3f85b9bd72d15639a3f68a6f598dc1e7c46d33206f76c5
| 15,696 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe11f708a6e5e114d27d347fcdb5061a201e934b6.sol
| 3,939 | 14,373 |
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 EtherWords is ERC721 {
/// @dev The Birth event is fired whenever a new Number 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 = "EtherWords"; // solhint-disable-line
string public constant SYMBOL = "WordToken"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private constant PROMO_CREATION_LIMIT = 10000;
uint256 private firstStepLimit = 0.053613 ether;
uint256 private secondStepLimit = 0.564957 ether;
uint256 private cooPrice = 50.0 ether;
/// @dev A mapping from person IDs to the address that owns them. All persons have
/// some valid owner address.
mapping (uint256 => address) public personIndexToOwner;
// @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 PersonIDs to an address that has been approved to call
/// transferFrom(). Each Person can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public personIndexToApproved;
// @dev A mapping from PersonIDs to the price of the token.
mapping (uint256 => uint256) private personIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
uint256 public promoCreatedCount;
struct Number {
string name;
}
Number[] private numbers;
/// @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 EtherWords() 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));
personIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
function createPromoNumber(address _owner, string _name, uint256 _price) public onlyCOO {
require(promoCreatedCount < PROMO_CREATION_LIMIT);
address personOwner = _owner;
if (personOwner == address(0)) {
personOwner = cooAddress;
}
if (_price <= 0) {
_price = startingPrice;
}
promoCreatedCount++;
_createPerson(_name, personOwner, _price);
}
/// @dev Creates a new Person with the given name.
function createContractNumber(string _name) public onlyCLevel {
_createPerson(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific person.
/// @param _tokenId The tokenId of the person of interest.
function getNumber(uint256 _tokenId) public view returns (string numberName,
uint256 sellingPrice,
address owner) {
Number storage number = numbers[_tokenId];
numberName = number.name;
sellingPrice = personIndexToPrice[_tokenId];
owner = personIndexToOwner[_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 = personIndexToOwner[_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 = personIndexToOwner[_tokenId];
address newOwner = msg.sender;
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
uint256 sellingPrice = personIndexToPrice[_tokenId];
// 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
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 92);
} else if (sellingPrice < secondStepLimit) {
// second stage
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 120), 92);
} else {
// third stage
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 92);
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.08)
}
TokenSold(_tokenId, sellingPrice, personIndexToPrice[_tokenId], oldOwner, newOwner, numbers[_tokenId].name);
msg.sender.transfer(purchaseExcess);
personIndexToPrice[0] = SafeMath.div(SafeMath.mul(personIndexToPrice[0], 101), 100);
if (_tokenId == 0) {
cooAddress = msg.sender;
personIndexToPrice[0] = SafeMath.div(SafeMath.mul(personIndexToPrice[0], 110), 100);
}
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return personIndexToPrice[_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 creates the genesis word.
function genesisCreation() public onlyCEO {
if (numbers.length == 0) {
_createPerson("EtherWords", address(this), cooPrice);
}
}
/// @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 = personIndexToOwner[_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 Persons array looking for persons 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 totalPersons = totalSupply();
uint256 resultIndex = 0;
uint256 personId;
for (personId = 0; personId <= totalPersons; personId++) {
if (personIndexToOwner[personId] == _owner) {
result[resultIndex] = personId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return numbers.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 personIndexToApproved[_tokenId] == _to;
}
/// For creating Person
function _createPerson(string _name, address _owner, uint256 _price) private {
Number memory _number = Number({
name: _name
});
uint256 newPersonId = numbers.push(_number) - 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(newPersonId == uint256(uint32(newPersonId)));
Birth(newPersonId, _name, _owner);
personIndexToPrice[newPersonId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newPersonId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == personIndexToOwner[_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 Person to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of persons is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
personIndexToOwner[_tokenId] = _to;
// When creating new persons _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete personIndexToApproved[_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;
}
}
| 147,843 | 13,874 |
57e1d058b1bf4fe3632756aaff504413cf2c367660e920cb8e2e0d1c9dffbe38
| 21,061 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/8177_9462_0xb119ce94d098c18fe380904c24e358bd887f00be.sol
| 3,580 | 13,935 |
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
newOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyNewOwner() {
require(msg.sender != address(0));
require(msg.sender == newOwner);
_;
}
function isOwner(address account) public view returns (bool) {
if(account == owner){
return true;
}
else {
return false;
}
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public onlyNewOwner returns(bool) {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract PauserRole is Ownable{
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender)|| isOwner(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function removePauser(address account) public onlyOwner {
_removePauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract MACH is ERC20Detailed, ERC20Pausable, ERC20Burnable {
struct LockInfo {
uint256 _releaseTime;
uint256 _amount;
}
address public implementation;
mapping (address => LockInfo[]) public timelockList;
mapping (address => bool) public frozenAccount;
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
event Lock(address indexed holder, uint256 value, uint256 releaseTime);
event Unlock(address indexed holder, uint256 value);
modifier notFrozen(address _holder) {
require(!frozenAccount[_holder]);
_;
}
constructor() ERC20Detailed("MACH Exchange", "MACH", 18) public {
_mint(msg.sender, 200000000 * (10 ** 18));
}
function balanceOf(address owner) public view returns (uint256) {
uint256 totalBalance = super.balanceOf(owner);
if(timelockList[owner].length >0){
for(uint i=0; i<timelockList[owner].length;i++){
totalBalance = totalBalance.add(timelockList[owner][i]._amount);
}
}
return totalBalance;
}
function transfer(address to, uint256 value) public notFrozen(msg.sender) returns (bool) {
if (timelockList[msg.sender].length > 0) {
_autoUnlock(msg.sender);
}
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public notFrozen(from) returns (bool) {
if (timelockList[from].length > 0) {
_autoUnlock(from);
}
return super.transferFrom(from, to, value);
}
function freezeAccount(address holder) public onlyPauser returns (bool) {
require(!frozenAccount[holder]);
frozenAccount[holder] = true;
emit Freeze(holder);
return true;
}
function unfreezeAccount(address holder) public onlyPauser returns (bool) {
require(frozenAccount[holder]);
frozenAccount[holder] = false;
emit Unfreeze(holder);
return true;
}
function lock(address holder, uint256 value, uint256 releaseTime) public onlyPauser returns (bool) {
require(_balances[holder] >= value,"There is not enough balances of holder.");
_lock(holder,value,releaseTime);
return true;
}
function transferWithLock(address holder, uint256 value, uint256 releaseTime) public onlyPauser returns (bool) {
_transfer(msg.sender, holder, value);
_lock(holder,value,releaseTime);
return true;
}
function unlock(address holder, uint256 idx) public onlyPauser returns (bool) {
require(timelockList[holder].length > idx, "There is not lock info.");
_unlock(holder,idx);
return true;
}
function upgradeTo(address _newImplementation) public onlyOwner {
require(implementation != _newImplementation);
_setImplementation(_newImplementation);
}
function _lock(address holder, uint256 value, uint256 releaseTime) internal returns(bool) {
_balances[holder] = _balances[holder].sub(value);
timelockList[holder].push(LockInfo(releaseTime, value));
emit Lock(holder, value, releaseTime);
return true;
}
function _unlock(address holder, uint256 idx) internal returns(bool) {
LockInfo storage lockinfo = timelockList[holder][idx];
uint256 releaseAmount = lockinfo._amount;
delete timelockList[holder][idx];
timelockList[holder][idx] = timelockList[holder][timelockList[holder].length.sub(1)];
timelockList[holder].length -=1;
emit Unlock(holder, releaseAmount);
_balances[holder] = _balances[holder].add(releaseAmount);
return true;
}
function _autoUnlock(address holder) internal returns(bool) {
for(uint256 idx =0; idx < timelockList[holder].length ; idx++) {
if (timelockList[holder][idx]._releaseTime <= now) {
// If lockupinfo was deleted, loop restart at same position.
if(_unlock(holder, idx)) {
idx -=1;
}
}
}
return true;
}
function _setImplementation(address _newImp) internal {
implementation = _newImp;
}
function () payable external {
address impl = implementation;
require(impl != address(0));
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, impl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
| 232,403 | 13,875 |
8a552d6b2307d5a7f816408a07b996cc533fb0fc7fc056c879a867ff67c6296a
| 29,231 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/AFGToken-0x9ee34ac75c049933c35b2c6b3ad00eb02ac9c7df.sol
| 3,396 | 12,613 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract AFGToken is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 200,623 | 13,876 |
f1016a4f1eae15472aead98425d39e3b646634585ef81f3b4fcddba9f885e96f
| 26,903 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1e/1e7d76aa8bf4fef09dc676224f7509fb6f819fad_Sorbettiere.sol
| 4,293 | 17,595 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
abstract contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
if (direct) {
require(newOwner != address(0) || renounce, "Ownable: zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} else {
pendingOwner = newOwner;
}
}
function claimOwnership() public {
address _pendingOwner = pendingOwner;
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// The contract is based on famous Masterchef contract (Ty guys for that)
// Future is crosschain...
// And the contract ownership will be transferred to other contract
contract Sorbettiere is Ownable {
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
uint256 remainingIceTokenReward; // ICE Tokens that weren't distributed for user per pool.
//
// We do some fancy math here. Basically, any point in time, the amount of ICE
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accICEPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws Staked tokens to a pool. Here's what happens:
// 1. The pool's `accICEPerShare` (and `lastRewardTime`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 stakingToken; // Contract address of staked token
uint256 stakingTokenTotalAmount; //Total amount of deposited tokens
uint256 accIcePerShare; // Accumulated ICE per share, times 1e12. See below.
uint32 lastRewardTime; // Last timestamp number that ICE distribution occurs.
uint16 allocPoint; // How many allocation points assigned to this pool. ICE to distribute per second.
}
IERC20 immutable public ice; // The ICE TOKEN!!
uint256 public icePerSecond; // Ice tokens vested per second.
PoolInfo[] public poolInfo; // Info of each pool.
mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Info of each user that stakes tokens.
uint256 public totalAllocPoint = 0; // Total allocation poitns. Must be the sum of all allocation points in all pools.
uint32 immutable public startTime; // The timestamp when ICE farming starts.
uint32 public endTime; // Time on which the reward calculation should end
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(IERC20 _ice,
uint256 _icePerSecond,
uint32 _startTime) {
ice = _ice;
icePerSecond = _icePerSecond;
startTime = _startTime;
endTime = _startTime + 7 days;
}
function changeEndTime(uint32 addSeconds) external onlyOwner {
endTime += addSeconds;
}
// which is entitled to the user for his token staking by the time the `endTime` is passed.
//Good practice to update pools without messing up the contract
function setIcePerSecond(uint256 _icePerSecond, bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
icePerSecond= _icePerSecond;
}
// How many pools are in the contract
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
// Add a new staking token to the pool. Can only be called by the owner.
// VERY IMPORTANT NOTICE
// Good practice to update pools without messing up the contract
function add(uint16 _allocPoint,
IERC20 _stakingToken,
bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardTime =
block.timestamp > startTime ? block.timestamp : startTime;
totalAllocPoint +=_allocPoint;
poolInfo.push(PoolInfo({
stakingToken: _stakingToken,
stakingTokenTotalAmount: 0,
allocPoint: _allocPoint,
lastRewardTime: uint32(lastRewardTime),
accIcePerShare: 0
}));
}
// Update the given pool's ICE allocation point. Can only be called by the owner.
// Good practice to update pools without messing up the contract
function set(uint256 _pid,
uint16 _allocPoint,
bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
poolInfo[_pid].allocPoint = _allocPoint;
}
// Return reward multiplier over the given _from to _to time.
function getMultiplier(uint256 _from, uint256 _to)
public
view
returns (uint256)
{
_from = _from > startTime ? _from : startTime;
if (_from > endTime || _to < startTime) {
return 0;
}
if (_to > endTime) {
return endTime - _from;
}
return _to - _from;
}
// View function to see pending ICE on frontend.
function pendingIce(uint256 _pid, address _user)
external
view
returns (uint256)
{
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accIcePerShare = pool.accIcePerShare;
if (block.timestamp > pool.lastRewardTime && pool.stakingTokenTotalAmount != 0) {
uint256 multiplier =
getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 iceReward =
multiplier * icePerSecond * pool.allocPoint / totalAllocPoint;
accIcePerShare += iceReward * 1e12 / pool.stakingTokenTotalAmount;
}
return user.amount * accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
if (pool.stakingTokenTotalAmount == 0) {
pool.lastRewardTime = uint32(block.timestamp);
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 iceReward =
multiplier * icePerSecond * pool.allocPoint / totalAllocPoint;
pool.accIcePerShare += iceReward * 1e12 / pool.stakingTokenTotalAmount;
pool.lastRewardTime = uint32(block.timestamp);
}
// Deposit staking tokens to Sorbettiere for ICE allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending =
user.amount * pool.accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
user.remainingIceTokenReward = safeRewardTransfer(msg.sender, pending);
}
pool.stakingToken.safeTransferFrom(address(msg.sender),
address(this),
_amount);
user.amount += _amount;
pool.stakingTokenTotalAmount += _amount;
user.rewardDebt = user.amount * pool.accIcePerShare / 1e12;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw staked tokens from Sorbettiere.
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "Sorbettiere: you cant eat that much popsicles");
updatePool(_pid);
uint256 pending =
user.amount * pool.accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
user.remainingIceTokenReward = safeRewardTransfer(msg.sender, pending);
user.amount -= _amount;
pool.stakingTokenTotalAmount -= _amount;
user.rewardDebt = user.amount * pool.accIcePerShare / 1e12;
pool.stakingToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 userAmount = user.amount;
pool.stakingTokenTotalAmount -= userAmount;
delete userInfo[_pid][msg.sender];
pool.stakingToken.safeTransfer(address(msg.sender), userAmount);
emit EmergencyWithdraw(msg.sender, _pid, userAmount);
}
// Safe ice transfer function. Just in case if the pool does not have enough ICE token,
// The function returns the amount which is owed to the user
function safeRewardTransfer(address _to, uint256 _amount) internal returns(uint256) {
uint256 iceTokenBalance = ice.balanceOf(address(this));
if (iceTokenBalance == 0) { //save some gas fee
return _amount;
}
if (_amount > iceTokenBalance) { //save some gas fee
ice.safeTransfer(_to, iceTokenBalance);
return _amount - iceTokenBalance;
}
ice.safeTransfer(_to, _amount);
return 0;
}
}
| 96,141 | 13,877 |
8211a19e7366718594f3ed2432e3d9b7463316edb073e051e1669fa7b9a401e6
| 27,167 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe15d6bd97391a97a538fbb4eaae8fcf76949d9cc.sol
| 4,901 | 19,095 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 public totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(msg.data.length>=(2*32)+4);
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer (msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(_value==0||allowed[msg.sender][_spender]==0);
require(msg.data.length>=(2*32)+4);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract Lock is PausableToken{
mapping(address => uint256) public teamLockTime; // Lock start time
mapping(address => uint256) public fundLockTime; // Lock start time
uint256 public issueDate =0 ;//issueDate
mapping(address => uint256) public teamLocked;// Total Team lock
mapping(address => uint256) public fundLocked;// Total fund lock
mapping(address => uint256) public teamUsed; // Team Used
mapping(address => uint256) public fundUsed; // Fund Used
mapping(address => uint256) public teamReverse; // Team reserve
mapping(address => uint256) public fundReverse; // Fund reserve
function teamAvailable(address _to) internal constant returns (uint256) {
require(teamLockTime[_to]>0);
//Cover the start time of the lock before the release is the issueDate
if(teamLockTime[_to] != issueDate)
{
teamLockTime[_to]= issueDate;
}
uint256 now1 = block.timestamp;
uint256 lockTime = teamLockTime[_to];
uint256 time = now1.sub(lockTime);
uint256 percent = 0;
if(time >= 30 days) {
percent = (time.div(30 days)) .add(1);
}
percent = percent > 12 ? 12 : percent;
uint256 avail = teamLocked[_to];
require(avail>0);
avail = avail.mul(percent).div(12).sub(teamUsed[_to]);
return avail ;
}
function fundAvailable(address _to) internal constant returns (uint256) {
require(fundLockTime[_to]>0);
//Cover the start time of the lock before the release is the issueDate
if(fundLockTime[_to] != issueDate)
{
fundLockTime[_to]= issueDate;
}
//The start time of the lock position
uint256 lockTime = fundLockTime[_to];
//The interval between the current time and the start time of the lockout
uint256 time = block.timestamp.sub(lockTime);
//Unlocked 25%
uint256 percent = 250;
//After more than 30 days, 75% of the minutes and 150 days of unlocking 5/1000 per day
if(time >= 30 days) {
percent = percent.add((((time.sub(30 days)).div (1 days)).add (1)).mul (5));
}
percent = percent > 1000 ? 1000 : percent;
uint256 avail = fundLocked[_to];
require(avail>0);
avail = avail.mul(percent).div(1000).sub(fundUsed[_to]);
return avail ;
}
function teamLock(address _to,uint256 _value) internal {
require(_value>0);
teamLocked[_to] = teamLocked[_to].add(_value);
teamReverse[_to] = teamReverse[_to].add(_value);
teamLockTime[_to] = block.timestamp; // Lock start time
}
function fundLock(address _to,uint256 _value) internal {
require(_value>0);
fundLocked[_to] =fundLocked[_to].add(_value);
fundReverse[_to] = fundReverse[_to].add(_value);
if(fundLockTime[_to] == 0)
fundLockTime[_to] = block.timestamp; // Lock start time
}
function teamLockTransfer(address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[msg.sender].sub((teamLocked[msg.sender].sub(teamUsed[msg.sender]))+(fundLocked[msg.sender].sub(fundUsed[msg.sender])));
uint256 totalAvail=0;
uint256 availTeam =0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
//the number of Tokens available for teamAccount'Locked part
availTeam = teamAvailable(msg.sender);
//the number of Tokens available for teamAccount
totalAvail = availTeam.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transfer(_to,_value);
if(ret == true && issueDate>0) {
//If over the teamAccount's released part
if(_value > availTeam){
teamUsed[msg.sender] = teamUsed[msg.sender].add(availTeam);
teamReverse[msg.sender] = teamReverse[msg.sender].sub(availTeam);
}
//If in the teamAccount's released part
else{
teamUsed[msg.sender] = teamUsed[msg.sender].add(_value);
teamReverse[msg.sender] = teamReverse[msg.sender].sub(_value);
}
}
if(teamUsed[msg.sender] >= teamLocked[msg.sender]){
delete teamLockTime[msg.sender];
delete teamReverse[msg.sender];
}
return ret;
}
function teamLockTransferFrom(address _from,address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[_from].sub((teamLocked[_from].sub(teamUsed[_from]))+(fundLocked[_from].sub(fundUsed[_from])));
uint256 totalAvail=0;
uint256 availTeam =0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
//the number of Tokens available for teamAccount'Locked part
availTeam = teamAvailable(_from);
//the number of Tokens available for teamAccount
totalAvail = availTeam.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transferFrom(_from,_to,_value);
if(ret == true && issueDate>0) {
//If over the teamAccount's released part
if(_value > availTeam){
teamUsed[_from] = teamUsed[_from].add(availTeam);
teamReverse[_from] = teamReverse[_from].sub(availTeam);
}
//If in the teamAccount's released part
else{
teamUsed[_from] = teamUsed[_from].add(_value);
teamReverse[_from] = teamReverse[_from].sub(_value);
}
}
if(teamUsed[_from] >= teamLocked[_from]){
delete teamLockTime[_from];
delete teamReverse[_from];
}
return ret;
}
function fundLockTransfer(address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[msg.sender].sub((teamLocked[msg.sender].sub(teamUsed[msg.sender]))+(fundLocked[msg.sender].sub(fundUsed[msg.sender])));
uint256 totalAvail=0;
uint256 availFund = 0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
require(now>issueDate);
//the number of Tokens available for mainFundAccount'Locked part
availFund = fundAvailable(msg.sender);
//the number of Tokens available for mainFundAccount
totalAvail = availFund.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transfer(_to,_value);
if(ret == true && issueDate>0) {
//If over the mainFundAccount's released part
if(_value > availFund){
fundUsed[msg.sender] = fundUsed[msg.sender].add(availFund);
fundReverse[msg.sender] = fundReverse[msg.sender].sub(availFund);
}
//If in the mainFundAccount's released part
else{
fundUsed[msg.sender] = fundUsed[msg.sender].add(_value);
fundReverse[msg.sender] = fundReverse[msg.sender].sub(_value);
}
}
if(fundUsed[msg.sender] >= fundLocked[msg.sender]){
delete fundLockTime[msg.sender];
delete fundReverse[msg.sender];
}
return ret;
}
function fundLockTransferFrom(address _from,address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[_from].sub((teamLocked[_from].sub(teamUsed[_from]))+(fundLocked[_from].sub(fundUsed[_from])));
uint256 totalAvail=0;
uint256 availFund = 0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
require(now>issueDate);
//the number of Tokens available for mainFundAccount'Locked part
availFund = fundAvailable(_from);
//the number of Tokens available for mainFundAccount
totalAvail = availFund.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transferFrom(_from,_to,_value);
if(ret == true && issueDate>0) {
//If over the mainFundAccount's released part
if(_value > availFund){
fundUsed[_from] = fundUsed[_from].add(availFund);
fundReverse[_from] = fundReverse[_from].sub(availFund);
}
//If in the mainFundAccount's released part
else{
fundUsed[_from] = fundUsed[_from].add(_value);
fundReverse[_from] = fundReverse[_from].sub(_value);
}
}
if(fundUsed[_from] >= fundLocked[_from]){
delete fundLockTime[_from];
}
return ret;
}
}
contract HitToken is Lock {
string public name;
string public symbol;
uint8 public decimals;
// Proportional accuracy
uint256 public precentDecimal = 2;
// mainFundPrecent
uint256 public mainFundPrecent = 2650;
//subFundPrecent
uint256 public subFundPrecent = 350;
//devTeamPrecent
uint256 public devTeamPrecent = 1500;
//hitFoundationPrecent
uint256 public hitFoundationPrecent = 5500;
//mainFundBalance
uint256 public mainFundBalance;
//subFundBalance
uint256 public subFundBalance;
//devTeamBalance
uint256 public devTeamBalance;
//hitFoundationBalance
uint256 public hitFoundationBalance;
//subFundAccount
address public subFundAccount;
//mainFundAccount
address public mainFundAccount;
function HitToken(string _name, string _symbol, uint8 _decimals, uint256 _initialSupply,address _teamAccount,address _subFundAccount,address _mainFundAccount,address _hitFoundationAccount) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
//Define a subFundAccount
subFundAccount = _subFundAccount;
//Define a mainFundAccount
mainFundAccount = _mainFundAccount;
totalSupply_ = _initialSupply * 10 ** uint256(_decimals);
//Calculate the total value of mainFund
mainFundBalance = totalSupply_.mul(mainFundPrecent).div(100* 10 ** precentDecimal) ;
//Calculate the total value of subFund
subFundBalance = totalSupply_.mul(subFundPrecent).div(100* 10 ** precentDecimal);
//Calculate the total value of devTeamBalance
devTeamBalance = totalSupply_.mul(devTeamPrecent).div(100* 10 ** precentDecimal);
//Calculate the total value of hitFoundationBalance
hitFoundationBalance = totalSupply_.mul(hitFoundationPrecent).div(100* 10 ** precentDecimal) ;
//Initially put the hitFoundationBalance into the hitFoundationAccount
balances[_hitFoundationAccount] = hitFoundationBalance;
//Initially put the devTeamBalance into the teamAccount
balances[_teamAccount] = devTeamBalance;
//Initially put the subFundBalance into the subFundAccount
balances[_subFundAccount] = subFundBalance;
//Initially put the mainFundBalance into the mainFundAccount
balances[_mainFundAccount]=mainFundBalance;
//Initially lock the team account
teamLock(_teamAccount,devTeamBalance);
}
function burn(uint256 _value) public onlyOwner returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[address(0)] = balances[address(0)].add(_value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
if(issueDate==0)
{
//the mainFundAccounts is not allowed to transfer before issued
require(msg.sender != mainFundAccount);
}
if(teamLockTime[msg.sender] > 0){
return super.teamLockTransfer(_to,_value);
}else if(fundLockTime[msg.sender] > 0){
return super.fundLockTransfer(_to,_value);
}else {
return super.transfer(_to, _value);
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(issueDate==0)
{
//the mainFundAccounts is not allowed to transfer before issued
require(_from != mainFundAccount);
}
if(teamLockTime[_from] > 0){
return super.teamLockTransferFrom(_from,_to,_value);
}else if(fundLockTime[_from] > 0){
return super.fundLockTransferFrom(_from,_to,_value);
}else{
return super.transferFrom(_from, _to, _value);
}
}
function mintFund(address _to, uint256 _value) public returns (bool){
require(msg.sender==mainFundAccount);
require(mainFundBalance >0);
require(_value >0);
if(_value <= mainFundBalance){
super.transfer(_to,_value);
fundLock(_to,_value);
mainFundBalance.sub(_value);
}
}
function issue() public onlyOwner returns (uint){
//Only one time
require(issueDate==0);
issueDate = now;
return now;
}
function() public payable{
revert();
}
}
| 145,228 | 13,878 |
b861ce96bae6cd7557c027933904e916cc6cc0573be831a86feb1a84a991956d
| 17,110 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbca4bd443716376b6284c682608b6bee03040b01.sol
| 3,832 | 16,314 |
pragma solidity 0.4.18;
interface ConversionRatesInterface {
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public;
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint);
}
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
interface SanityRatesInterface {
function getSanityRate(ERC20 src, ERC20 dest) public view returns(uint);
}
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
interface FundWalletInterface {
function() public payable;
function pullToken(ERC20 token, uint amount) external returns (bool);
function pullEther(uint amount) external returns (bool);
function checkBalance(ERC20 token) public view returns (uint);
}
/// @title Kyber Fund Reserve contract
contract KyberFundReserve is KyberReserveInterface, Withdrawable, Utils {
address public kyberNetwork;
bool public tradeEnabled;
ConversionRatesInterface public conversionRatesContract;
SanityRatesInterface public sanityRatesContract;
FundWalletInterface public fundWalletContract;
mapping(bytes32=>bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
function KyberFundReserve(address _kyberNetwork, ConversionRatesInterface _ratesContract, FundWalletInterface _fundWallet, address _admin) public {
require(_admin != address(0));
require(_ratesContract != address(0));
require(_kyberNetwork != address(0));
require(_fundWallet != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _ratesContract;
fundWalletContract = _fundWallet;
admin = _admin;
tradeEnabled = true;
}
event DepositToken(ERC20 token, uint amount);
function() public payable {
DepositToken(ETH_TOKEN_ADDRESS, msg.value);
}
event TradeExecute(address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address destAddress);
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool)
{
require(tradeEnabled);
require(msg.sender == kyberNetwork);
require(doTrade(srcToken, srcAmount, destToken, destAddress, conversionRate, validate));
return true;
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
tradeEnabled = true;
TradeEnabled(true);
return true;
}
function disableTrade() public onlyAlerter returns(bool) {
tradeEnabled = false;
TradeEnabled(false);
return true;
}
event WithdrawAddressApproved(ERC20 token, address addr, bool approve);
function approveWithdrawAddress(ERC20 token, address addr, bool approve) public onlyAdmin {
approvedWithdrawAddresses[keccak256(token, addr)] = approve;
WithdrawAddressApproved(token, addr, approve);
setDecimals(token);
}
function setFundWallet(FundWalletInterface _fundWallet) public onlyAdmin {
require(_fundWallet != address(0x0));
fundWalletContract = _fundWallet;
}
event WithdrawFunds(ERC20 token, uint amount, address destination);
function withdraw(ERC20 token, uint amount, address destination) public onlyOperator returns(bool) {
require(approvedWithdrawAddresses[keccak256(token, destination)]);
if (token == ETH_TOKEN_ADDRESS) {
require(ethPuller(amount));
destination.transfer(amount);
} else {
require(tokenPuller(token, amount));
require(token.transfer(destination, amount));
}
WithdrawFunds(token, amount, destination);
return true;
}
event SetContractAddresses(address network, address rate, address sanity);
function setContracts(address _kyberNetwork,
ConversionRatesInterface _conversionRates,
SanityRatesInterface _sanityRates)
public
onlyAdmin
{
require(_kyberNetwork != address(0));
require(_conversionRates != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _conversionRates;
sanityRatesContract = _sanityRates;
SetContractAddresses(kyberNetwork, conversionRatesContract, sanityRatesContract);
}
////////////////////////////////////////////////////////////////////////////
/// status functions ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function getBalance(ERC20 token) public view returns(uint) {
return fetchBalance(token);
}
function fetchBalance(ERC20 token) public view returns(uint) {
return fundWalletContract.checkBalance(token);
}
function getDestQty(ERC20 src, ERC20 dest, uint srcQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcDstQty(srcQty, srcDecimals, dstDecimals, rate);
}
function getSrcQty(ERC20 src, ERC20 dest, uint dstQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcSrcQty(dstQty, srcDecimals, dstDecimals, rate);
}
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) {
ERC20 token;
bool isBuy;
if (!tradeEnabled) return 0;
if (ETH_TOKEN_ADDRESS == src) {
isBuy = true;
token = dest;
} else if (ETH_TOKEN_ADDRESS == dest) {
isBuy = false;
token = src;
} else {
return 0; // pair is not listed
}
uint rate = conversionRatesContract.getRate(token, blockNumber, isBuy, srcQty);
uint destQty = getDestQty(src, dest, srcQty, rate);
if (getBalance(dest) < destQty) return 0;
if (sanityRatesContract != address(0)) {
uint sanityRate = sanityRatesContract.getSanityRate(src, dest);
if (rate > sanityRate) return 0;
}
return rate;
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validate If true, additional validations are applicable
/// @return true iff trade is successful
function doTrade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
internal
returns(bool)
{
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0);
if (srcToken == ETH_TOKEN_ADDRESS)
require(msg.value == srcAmount);
else
require(msg.value == 0);
}
uint destAmount = getDestQty(srcToken, destToken, srcAmount, conversionRate);
// sanity check
require(destAmount > 0);
// add to imbalance
ERC20 token;
int tradeAmount;
if (srcToken == ETH_TOKEN_ADDRESS) {
tradeAmount = int(destAmount);
token = destToken;
} else {
tradeAmount = -1 * int(srcAmount);
token = srcToken;
}
conversionRatesContract.recordImbalance(token,
tradeAmount,
0,
block.number);
// collect src tokens (if eth forward to fund Wallet)
if (srcToken == ETH_TOKEN_ADDRESS) {
//require push eth function
require(ethPusher(srcAmount));
} else {
require(srcToken.transferFrom(msg.sender, fundWalletContract, srcAmount));
}
// send dest tokens
if (destToken == ETH_TOKEN_ADDRESS) {
//require pull eth function then send eth to dest address;
require(ethPuller(destAmount));
destAddress.transfer(destAmount);
} else {
//require pull token function then send token to dest address;
require(tokenPuller(destToken, destAmount));
require(destToken.transfer(destAddress, destAmount));
}
TradeExecute(msg.sender, srcToken, srcAmount, destToken, destAmount, destAddress);
return true;
}
//push eth function
function ethPusher(uint srcAmount) internal returns(bool) {
fundWalletContract.transfer(srcAmount);
return true;
}
//pull eth functions
function ethPuller(uint destAmount) internal returns(bool) {
require(fundWalletContract.pullEther(destAmount));
return true;
}
//pull token function
function tokenPuller(ERC20 token, uint destAmount) internal returns(bool) {
require(fundWalletContract.pullToken(token, destAmount));
return true;
}
}
| 197,220 | 13,879 |
7452cb120310a8a7a0c2c6517dbc1c011abfc3accd3fa7bbb7d533412962a190
| 26,560 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8d/8dbc06c585f330235381644e66e29fe8df10deb1_AVAXGMPublicMint.sol
| 3,068 | 12,185 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.3.2 (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// 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;
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AVAXGMPublicMint is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable GM;
address public immutable AVAX;
// mint quota per wallet
uint public immutable MintQuota;
uint public immutable TotalMint;
uint mintPrice;
bool private isDeposit;
mapping(address => uint256) private _usedQuota;
constructor () {
GM = 0xB2c302E422DA0F1b56AE97f7e84D9Cd5707CE560;
AVAX = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7;
TotalMint = IERC20(GM).totalSupply() / 20; // 5% of total supply
MintQuota = TotalMint / 10 ** 3; // 1000 public mint wallet
mintPrice = 10 ** 17 / MintQuota; // 0.1 AVAX per sale
require(IERC20(GM).balanceOf(_msgSender()) >= MintQuota);
}
// depositMintQuota - only called once by GM original owner
function depositMintQuota() external onlyOwner {
require(!isDeposit);
IERC20(GM).safeTransferFrom(_msgSender(), address(this), TotalMint);
isDeposit = true;
}
function contractBalance() public view returns (uint) {
return IERC20(GM).balanceOf(address(this));
}
// function called by public wallet
function publicMint(uint256 amount) payable external {
require(amount <= contractBalance());
require(amount + _usedQuota[_msgSender()] <= MintQuota);
require(msg.value == mintPrice * amount);
_usedQuota[_msgSender()] = _usedQuota[_msgSender()] + amount;
IERC20(GM).transfer(_msgSender(), amount);
}
}
| 100,403 | 13,880 |
a8318d7e0138e31e489f029a9793605f9781dadc26495b9340528eee7eeaaaf4
| 15,873 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x5f30dca1c90708e8b5b0b047be6b73e4bcae6238.sol
| 3,803 | 14,748 |
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 multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has five types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
constructor(address[] _owners, uint _required) public {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
PendingState storage pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
emit Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(keccak256(abi.encodePacked(msg.data, block.number))) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
emit OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(keccak256(abi.encodePacked(msg.data, block.number))) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
emit OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(keccak256(abi.encodePacked(msg.data, block.number))) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
emit OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(keccak256(abi.encodePacked(msg.data, block.number))) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
emit RequirementChanged(_newRequired);
}
function isOwner(address _addr) public view returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) public view returns (bool) {
PendingState storage pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
if (pending.ownersDone & ownerIndexBit == 0) {
return false;
} else {
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
PendingState storage pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
emit Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private returns (bool) {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
if (m_pendingIndex[i] != 0) {
delete m_pending[m_pendingIndex[i]];
}
}
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
}
// uses is specified in the modifier.
contract daylimit is multiowned {
// MODIFIERS
// simple modifier for daily limit.
modifier limitedDaily(uint _value) {
if (underLimit(_value))
_;
}
// METHODS
// constructor - stores initial daily limit and records the present day's index.
constructor(uint _limit) public {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(keccak256(abi.encodePacked(msg.data, block.number))) external {
m_dailyLimit = _newLimit;
}
function resetSpentToday() onlymanyowners(keccak256(abi.encodePacked(msg.data, block.number))) external {
m_spentToday = 0;
}
// INTERNAL METHODS
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private view returns (uint) { return block.timestamp / 1 days; }
// FIELDS
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address from, uint value);
event SingleTransact(address owner, uint value, address to);
event MultiTransact(address owner, bytes32 operation, uint value, address to);
// Confirmation still needed for a transaction.
event ConfirmationERC20Needed(bytes32 operation, address initiator, uint value, address to, ERC20Basic token);
event ConfirmationETHNeeded(bytes32 operation, address initiator, uint value, address to);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
//function execute(address _to, uint _value, bytes _data) external returns (bytes32);
//function confirm(bytes32 _h) public returns (bool);
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).transact(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit {
uint public version = 3;
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
address token;
}
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
constructor(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) public {
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(keccak256(abi.encodePacked(msg.data, block.number))) external {
selfdestruct(_to);
}
// gets called when no other function matches
function() public payable {
// just being sent some cash?
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transacion immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function transferETH(address _to, uint _value) external onlyowner returns (bytes32 _r) {
// first, take the opportunity to check that we're under the daily limit.
if (underLimit(_value)) {
emit SingleTransact(msg.sender, _value, _to);
// yes - just execute the call.
_to.transfer(_value);
return 0;
}
// determine our operation hash.
_r = keccak256(abi.encodePacked(msg.data, block.number));
if (!confirmETH(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
emit ConfirmationETHNeeded(_r, msg.sender, _value, _to);
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirmETH(bytes32 _h) onlymanyowners(_h) public returns (bool) {
if (m_txs[_h].to != 0) {
m_txs[_h].to.transfer(m_txs[_h].value);
emit MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to);
delete m_txs[_h];
return true;
}
}
function transferERC20(address _to, uint _value, address _token) external onlyowner returns (bytes32 _r) {
// first, take the opportunity to check that we're under the daily limit.
if (underLimit(_value)) {
emit SingleTransact(msg.sender, _value, _to);
// yes - just execute the call.
ERC20Basic token = ERC20Basic(_token);
token.transfer(_to, _value);
return 0;
}
// determine our operation hash.
_r = keccak256(abi.encodePacked(msg.data, block.number));
if (!confirmERC20(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].token = _token;
emit ConfirmationERC20Needed(_r, msg.sender, _value, _to, token);
}
}
function confirmERC20(bytes32 _h) onlymanyowners(_h) public returns (bool) {
if (m_txs[_h].to != 0) {
ERC20Basic token = ERC20Basic(m_txs[_h].token);
token.transfer(m_txs[_h].to, m_txs[_h].value);
emit MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
| 213,886 | 13,881 |
14a17064721dffffd9d2765d5eb2172d5e74053aea291e88bacd48723b96ea85
| 12,931 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0xf953990d2d8388bfca220141fad56e74d66184ac.sol
| 3,211 | 12,450 |
pragma solidity 0.4.19;
contract Admin {
address public godAddress;
address public managerAddress;
address public bursarAddress;
// God has more priviledges than other admins
modifier requireGod() {
require(msg.sender == godAddress);
_;
}
modifier requireManager() {
require(msg.sender == managerAddress);
_;
}
modifier requireAdmin() {
require(msg.sender == managerAddress || msg.sender == godAddress);
_;
}
modifier requireBursar() {
require(msg.sender == bursarAddress);
_;
}
/// @notice Assigns a new address to act as the God. Only available to the current God.
/// @param _newGod The address of the new God
function setGod(address _newGod) external requireGod {
require(_newGod != address(0));
godAddress = _newGod;
}
/// @notice Assigns a new address to act as the Manager. Only available to the current God.
/// @param _newManager The address of the new Manager
function setManager(address _newManager) external requireGod {
require(_newManager != address(0));
managerAddress = _newManager;
}
/// @notice Assigns a new address to act as the Bursar. Only available to the current God.
/// @param _newBursar The address of the new Bursar
function setBursar(address _newBursar) external requireGod {
require(_newBursar != address(0));
bursarAddress = _newBursar;
}
/// @notice !!! COMPLETELY DESTROYS THE CONTRACT !!!
function destroy() external requireGod {
selfdestruct(godAddress);
}
}
contract Pausable is Admin {
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() external requireAdmin whenNotPaused {
paused = true;
}
function unpause() external requireGod whenPaused {
paused = false;
}
}
contract CryptoFamousBase is Pausable {
// DATA TYPES
struct Card {
// Social network type id (1 - Twitter, others TBD)
uint8 socialNetworkType;
// The social network id of the social account backing this card.
uint64 socialId;
// The ethereum address that most recently claimed this card.
address claimer;
// Increased whenever the card is claimed by an address
uint16 claimNonce;
// Reserved for future use
uint8 reserved1;
}
struct SaleInfo {
uint128 timestamp;
uint128 price;
}
}
contract CryptoFamousOwnership is CryptoFamousBase {
// EVENTS
event CardCreated(uint256 indexed cardId, uint8 socialNetworkType, uint64 socialId, address claimer, address indexed owner);
// STORAGE
/// @dev contains all the Cards in the system. Card with ID 0 is invalid.
Card[] public allCards;
/// @dev SocialNetworkType -> (SocialId -> CardId)
mapping (uint8 => mapping (uint64 => uint256)) private socialIdentityMappings;
/// @dev getter for `socialIdentityMappings`
function socialIdentityToCardId(uint256 _socialNetworkType, uint256 _socialId) public view returns (uint256 cardId) {
uint8 _socialNetworkType8 = uint8(_socialNetworkType);
require(_socialNetworkType == uint256(_socialNetworkType8));
uint64 _socialId64 = uint64(_socialId);
require(_socialId == uint256(_socialId64));
cardId = socialIdentityMappings[_socialNetworkType8][_socialId64];
return cardId;
}
mapping (uint8 => mapping (address => uint256)) private claimerAddressToCardIdMappings;
/// @dev returns the last Card ID claimed by `_claimerAddress` in network with `_socialNetworkType`
function lookUpClaimerAddress(uint256 _socialNetworkType, address _claimerAddress) public view returns (uint256 cardId) {
uint8 _socialNetworkType8 = uint8(_socialNetworkType);
require(_socialNetworkType == uint256(_socialNetworkType8));
cardId = claimerAddressToCardIdMappings[_socialNetworkType8][_claimerAddress];
return cardId;
}
/// @dev A mapping from Card ID to the timestamp of the first completed Claim of that Card
mapping (uint256 => uint128) public cardIdToFirstClaimTimestamp;
/// @dev A mapping from Card ID to the current owner address of that Card
mapping (uint256 => address) public cardIdToOwner;
/// @dev A mapping from owner address to the number of Cards currently owned by it
mapping (address => uint256) internal ownerAddressToCardCount;
function _changeOwnership(address _from, address _to, uint256 _cardId) internal whenNotPaused {
ownerAddressToCardCount[_to]++;
cardIdToOwner[_cardId] = _to;
if (_from != address(0)) {
ownerAddressToCardCount[_from]--;
}
}
function _recordFirstClaimTimestamp(uint256 _cardId) internal {
cardIdToFirstClaimTimestamp[_cardId] = uint128(now); //solhint-disable-line not-rely-on-time
}
function _createCard(uint256 _socialNetworkType,
uint256 _socialId,
address _owner,
address _claimer)
internal
whenNotPaused
returns (uint256)
{
uint8 _socialNetworkType8 = uint8(_socialNetworkType);
require(_socialNetworkType == uint256(_socialNetworkType8));
uint64 _socialId64 = uint64(_socialId);
require(_socialId == uint256(_socialId64));
uint16 claimNonce = 0;
if (_claimer != address(0)) {
claimNonce = 1;
}
Card memory _card = Card({
socialNetworkType: _socialNetworkType8,
socialId: _socialId64,
claimer: _claimer,
claimNonce: claimNonce,
reserved1: 0
});
uint256 newCardId = allCards.push(_card) - 1;
socialIdentityMappings[_socialNetworkType8][_socialId64] = newCardId;
if (_claimer != address(0)) {
claimerAddressToCardIdMappings[_socialNetworkType8][_claimer] = newCardId;
_recordFirstClaimTimestamp(newCardId);
}
CardCreated(newCardId,
_socialNetworkType8,
_socialId64,
_claimer,
_owner);
_changeOwnership(0, _owner, newCardId);
return newCardId;
}
/// @dev Returns the toal number of Cards in existence
function totalNumberOfCards() public view returns (uint) {
return allCards.length - 1;
}
/// @notice Returns a list of all Card IDs currently owned by `_owner`
/// @dev (this thing iterates, don't call from smart contract code)
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = ownerAddressToCardCount[_owner];
if (tokenCount == 0) {
return new uint256[](0);
}
uint256[] memory result = new uint256[](tokenCount);
uint256 total = totalNumberOfCards();
uint256 resultIndex = 0;
uint256 cardId;
for (cardId = 1; cardId <= total; cardId++) {
if (cardIdToOwner[cardId] == _owner) {
result[resultIndex] = cardId;
resultIndex++;
}
}
return result;
}
}
contract CryptoFamousStorage is CryptoFamousOwnership {
function CryptoFamousStorage() public {
godAddress = msg.sender;
managerAddress = msg.sender;
bursarAddress = msg.sender;
// avoid zero identifiers
_createCard(0, 0, address(0), address(0));
}
function() external payable {
// just let msg.value be added to this.balance
FallbackEtherReceived(msg.sender, msg.value);
}
event FallbackEtherReceived(address from, uint256 value);
address public authorizedLogicContractAddress;
modifier requireAuthorizedLogicContract() {
require(msg.sender == authorizedLogicContractAddress);
_;
}
/// @dev mapping from Card ID to information about that card's last trade
mapping (uint256 => SaleInfo) public cardIdToSaleInfo;
/// @dev mapping from Card ID to the current value stashed away for a future claimer
mapping (uint256 => uint256) public cardIdToStashedPayout;
/// @dev total amount of stashed payouts
uint256 public totalStashedPayouts;
/// @dev if we fail to send any value to a Card's previous owner as part of the
/// invite/steal transaction we'll hold it in this contract. This mapping records the amount
/// owed to that "previous owner".
mapping (address => uint256) public addressToFailedOldOwnerTransferAmount;
/// @dev total amount of failed old owner transfers
uint256 public totalFailedOldOwnerTransferAmounts;
/// @dev mapping from Card ID to that card's current perk text
mapping (uint256 => string) public cardIdToPerkText;
function authorized_setCardPerkText(uint256 _cardId, string _perkText) external requireAuthorizedLogicContract {
cardIdToPerkText[_cardId] = _perkText;
}
function setAuthorizedLogicContractAddress(address _newAuthorizedLogicContractAddress) external requireGod {
authorizedLogicContractAddress = _newAuthorizedLogicContractAddress;
}
function authorized_changeOwnership(address _from, address _to, uint256 _cardId) external requireAuthorizedLogicContract {
_changeOwnership(_from, _to, _cardId);
}
function authorized_createCard(uint256 _socialNetworkType, uint256 _socialId, address _owner, address _claimer) external requireAuthorizedLogicContract returns (uint256) {
return _createCard(_socialNetworkType, _socialId, _owner, _claimer);
}
function authorized_updateSaleInfo(uint256 _cardId, uint256 _sentValue) external requireAuthorizedLogicContract {
cardIdToSaleInfo[_cardId] = SaleInfo(uint128(now), uint128(_sentValue)); // solhint-disable-line not-rely-on-time
}
function authorized_updateCardClaimerAddress(uint256 _cardId, address _claimerAddress) external requireAuthorizedLogicContract {
Card storage card = allCards[_cardId];
if (card.claimer == address(0)) {
_recordFirstClaimTimestamp(_cardId);
}
card.claimer = _claimerAddress;
card.claimNonce += 1;
}
function authorized_updateCardReserved1(uint256 _cardId, uint8 _reserved) external requireAuthorizedLogicContract {
uint8 _reserved8 = uint8(_reserved);
require(_reserved == uint256(_reserved8));
Card storage card = allCards[_cardId];
card.reserved1 = _reserved8;
}
function authorized_triggerStashedPayoutTransfer(uint256 _cardId) external requireAuthorizedLogicContract {
Card storage card = allCards[_cardId];
address claimerAddress = card.claimer;
require(claimerAddress != address(0));
uint256 stashedPayout = cardIdToStashedPayout[_cardId];
require(stashedPayout > 0);
cardIdToStashedPayout[_cardId] = 0;
totalStashedPayouts -= stashedPayout;
claimerAddress.transfer(stashedPayout);
}
function authorized_recordStashedPayout(uint256 _cardId) external payable requireAuthorizedLogicContract {
cardIdToStashedPayout[_cardId] += msg.value;
totalStashedPayouts += msg.value;
}
function authorized_recordFailedOldOwnerTransfer(address _oldOwner) external payable requireAuthorizedLogicContract {
addressToFailedOldOwnerTransferAmount[_oldOwner] += msg.value;
totalFailedOldOwnerTransferAmounts += msg.value;
}
// solhint-disable-next-line no-empty-blocks
function authorized_recordPlatformFee() external payable requireAuthorizedLogicContract {
// just let msg.value be added to this.balance
}
/// @dev returns the current contract balance after subtracting the amounts stashed away for others
function netContractBalance() public view returns (uint256 balance) {
balance = this.balance - totalStashedPayouts - totalFailedOldOwnerTransferAmounts;
return balance;
}
/// @dev the Bursar account can use this to withdraw the contract's net balance
function bursarPayOutNetContractBalance(address _to) external requireBursar {
uint256 payout = netContractBalance();
if (_to == address(0)) {
bursarAddress.transfer(payout);
} else {
_to.transfer(payout);
}
}
/// @dev Any wallet owed value that's recorded under `addressToFailedOldOwnerTransferAmount`
/// can use this function to withdraw that value.
function withdrawFailedOldOwnerTransferAmount() external whenNotPaused {
uint256 failedTransferAmount = addressToFailedOldOwnerTransferAmount[msg.sender];
require(failedTransferAmount > 0);
addressToFailedOldOwnerTransferAmount[msg.sender] = 0;
totalFailedOldOwnerTransferAmounts -= failedTransferAmount;
msg.sender.transfer(failedTransferAmount);
}
}
| 136,233 | 13,882 |
d9a21ede27c224a3ed8eb2977ff8e5c954916ba1df9f0c2ad94eb016a411f5da
| 35,610 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/32/32b9AdBf14B9bfdDbAb3d4474804402775B48eC8_StrudelPresale.sol
| 5,169 | 20,089 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StrudelPresale is ReentrancyGuard, Context, Ownable, Pausable {
using ECDSA for bytes32;
IERC20 public token;
address payable public daoAddress;
address public whitelistSigner;
uint256 public rate;
uint256 public ftmRaised;
uint256 public endICO;
uint256 public rewardTokenCount;
uint256 public minPurchase;
uint256 public maxPurchase;
uint256 public availableTokensICO;
uint256 public boughtTokensICO;
uint256 public maxTokensICO;
// bytes32 -> DomainSeparator
bytes32 public DOMAIN_SEPARATOR;
// bytes32 -> PRESALE_TYPEHASH
bytes32 public constant PRESALE_TYPEHASH = keccak256("Presale(address buyer)");
struct Whitelist {
address wallet;
uint256 amountToReceive;
uint256 ftmSpend;
}
mapping(address => Whitelist) public whitelist;
event TokensPurchased(address indexed _beneficiary, address indexed _daoAddress, uint256 _amount);
event StartICO(uint256 _block);
event EndICO(uint256 _block);
event TokenAddress(address token);
event WithdrawLeftovers(address _user, uint256 _amount);
event WithdrawRewards(address _user, uint256 _amount);
event DistrubutedAmount(address _user, uint256 _amount);
event MinPurchase(uint256 _amount);
event MaxPurchase(uint256 _amount);
event MaxTokensICO(uint256 _amount);
event Rate(uint256 _amount);
event WhitelistSigner(address _whitelistSigner);
event AvailableTokensICO(uint256 _amount);
event DaoAddress(address payable _amount);
event RewardTokenCount(uint256 _amount);
event ForwardFunds(address _user, uint256 _amount);
modifier icoActive() {
require(endICO > 0 && block.number < endICO && availableTokensICO > 0, "ICO must be active");
_;
}
modifier icoNotActive() {
require(endICO < block.number, 'ICO is active');
_;
}
constructor (address payable _daoAddress,
address _whitelistSigner,
uint256 _rate,
uint256 _availableTokensICO,
uint256 _rewardTokenCount,
uint256 _minPurchase,
uint256 _maxPurchase) public {
require(_daoAddress != address(0), "Pre-Sale: wallet is the zero address");
daoAddress = _daoAddress;
availableTokensICO = _availableTokensICO;
whitelistSigner = _whitelistSigner;
maxTokensICO = _availableTokensICO;
rewardTokenCount = _rewardTokenCount;
minPurchase = _minPurchase;
maxPurchase = _maxPurchase;
endICO = block.number + 999999999;
rate = _rate;
uint256 chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("ORKAN")),
keccak256(bytes("1")),
chainId,
address(this)));
emit Rate(rate);
emit EndICO(endICO);
emit MaxPurchase(_maxPurchase);
emit MinPurchase(_minPurchase);
emit AvailableTokensICO(_availableTokensICO);
emit MaxTokensICO(maxTokensICO);
emit DaoAddress(daoAddress);
}
function startICOSale(uint256 _endICO, uint256 _minPurchase, uint256 _maxPurchase, uint256 _availableTokensICO) external onlyOwner icoNotActive() {
require(_endICO != 0, 'Pre-Sale: The duration should be > 0');
require(_availableTokensICO > 0, 'Pre-Sale: The available tokens should be > 0');
require(_maxPurchase > 0, 'Pre-Sale: The max purchase should be > 0');
endICO = _endICO;
minPurchase = _minPurchase;
maxPurchase = _maxPurchase;
availableTokensICO = _availableTokensICO;
emit EndICO(_endICO);
emit MinPurchase(_minPurchase);
emit MaxPurchase(_maxPurchase);
emit AvailableTokensICO(_availableTokensICO);
emit TokenAddress(address(token));
}
function endICOSale(uint256 _endICO) external onlyOwner {
endICO = _endICO;
emit EndICO(_endICO);
}
function buyTokens(bytes memory signature) external nonReentrant icoActive whenNotPaused payable {
// Verify EIP-712 signature
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, keccak256(abi.encode(PRESALE_TYPEHASH, _msgSender()))));
address recoveredAddress = digest.recover(signature);
// Is the signature the same as the whitelist signer if yes? your able to mint.
require(recoveredAddress != address(0) && recoveredAddress == address(whitelistSigner), "Invalid signature");
uint256 ftmPurchaseInWei = msg.value;
uint256 tokensPurchase = getTokenAmount(ftmPurchaseInWei);
// _validatePurchase(ftmPurchaseInWei, tokensPurchase, _msgSender());
// Amount of FTM that has been raised
ftmRaised = ftmRaised + ftmPurchaseInWei;
// Add person to distrubuted map and tokens bought
whitelist[_msgSender()].wallet = _msgSender();
whitelist[_msgSender()].amountToReceive += tokensPurchase;
whitelist[_msgSender()].ftmSpend += ftmPurchaseInWei;
availableTokensICO = availableTokensICO - tokensPurchase;
boughtTokensICO += tokensPurchase;
// Send the funds to the daoAddress
daoAddress.transfer(msg.value);
emit TokensPurchased(_msgSender(), daoAddress, tokensPurchase);
}
function setToken(IERC20 _token) external onlyOwner {
require(address(token) != address(0), "Pre-Sale: Token is the zero address");
token = _token;
emit TokenAddress(address(token));
}
function setDistributedAmount(address _wallet, uint256 _amountInGwei) external onlyOwner {
whitelist[_wallet].amountToReceive = _amountInGwei;
emit DistrubutedAmount(_wallet, _amountInGwei);
}
function setRate(uint256 _rate) external onlyOwner {
rate = _rate;
emit Rate(rate);
}
function setPaused(bool _paused) external onlyOwner {
if (_paused) _pause();
else _unpause();
}
function setAvailableTokensICO(uint256 _availableTokensICO) public onlyOwner {
availableTokensICO = _availableTokensICO;
emit AvailableTokensICO(_availableTokensICO);
}
function setWhitelistSigner(address _whitelistSigner) public onlyOwner {
require(_whitelistSigner != address(0), "Pre-Sale: Invalid address");
whitelistSigner = _whitelistSigner;
emit WhitelistSigner(_whitelistSigner);
}
function setDaoAddress(address payable _daoAddress) external onlyOwner {
require(_daoAddress != address(0), "Pre-Sale: Invalid address");
daoAddress = _daoAddress;
emit DaoAddress(daoAddress);
}
function setMinPurchase(uint256 _minPurchase) external onlyOwner {
minPurchase = _minPurchase;
emit MinPurchase(_minPurchase);
}
function setMaxPurchase(uint256 _maxPurchase) external onlyOwner {
maxPurchase = _maxPurchase;
emit MaxPurchase(_maxPurchase);
}
function setRewardTokenCount(uint256 _rewardTokenCount) external onlyOwner {
rewardTokenCount = _rewardTokenCount;
emit RewardTokenCount(rewardTokenCount);
}
function getTokenAmount(uint256 _weiAmount) public view returns (uint256) {
return (_weiAmount * rewardTokenCount) / rate;
}
function getTokensInContract() public view returns (uint256) {
return token.balanceOf(address(this));
}
function withdrawalAmount(address _beneficiary) public view returns(uint256 amount) {
return whitelist[_beneficiary].amountToReceive;
}
function isWhitelisted(address _beneficiary, bytes memory signature) public view returns(bool) {
// Verify EIP-712 signature
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, keccak256(abi.encode(PRESALE_TYPEHASH, _beneficiary))));
address recoveredAddress = digest.recover(signature);
if(recoveredAddress != address(0) && recoveredAddress == address(whitelistSigner)) {
return true;
} else {
return false;
}
}
function withdrawLeftoversToken() external icoNotActive onlyOwner {
require(token.balanceOf(address(this)) > 0, 'Pre-Sale: Their is no tokens to withdraw');
token.approve(address(this), token.balanceOf(address(this)));
token.transfer(_msgSender(), token.balanceOf(address(this)));
emit WithdrawLeftovers(_msgSender(), token.balanceOf(address(this)));
}
function withdrawTokens() external nonReentrant whenNotPaused icoNotActive() {
require(address(token) != address(0), "Pre-Sale: Token is the zero address");
require(withdrawalAmount(_msgSender()) != 0, "Pre-Sale: Haven't bought any tokens");
require(withdrawalAmount(_msgSender()) <= getTokensInContract(), "Pre-Sale: Not enough tokens in contract to withdraw from");
token.transfer(_msgSender(), withdrawalAmount(_msgSender()));
whitelist[_msgSender()].amountToReceive = 0;
emit WithdrawRewards(_msgSender(), withdrawalAmount(_msgSender()));
}
// require(_ftmPurchaseInWei >= minPurchase, 'Pre-Sale: Have to send at least: minPurchase');
// require(_ftmPurchaseInWei <= maxPurchase, 'Pre-Sale: Have to send less than: maxPurchase');
// require(availableTokensICO != 0, "Pre-Sale: No available tokens left");
// require(_tokensPurchase != 0, "Pre-Sale: Value is 0");
// require(_tokensPurchase <= availableTokensICO, "Pre-Sale: No tokens left to buy");
// require(availableTokensICO - _tokensPurchase != 0, "Pre-Sale: Purchase amount is to high");
// }
}
| 326,102 | 13,883 |
e64687f0e25e95bf021b71603cc02d2fecde6d430b91febeb94cb1238b50e26d
| 27,133 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x87b1AccE6a1958E522233A737313C086551a5c76/contract.sol
| 4,795 | 17,771 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// File: openzeppelin-solidity\contracts\token\ERC20\IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: openzeppelin-solidity\contracts\utils\Address.sol
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 fBNB is IERC20 {
using Address for address;
enum TxType { FromExcluded, ToExcluded, BothExcluded, Standard }
mapping (address => uint256) private rBnbBalance;
mapping (address => uint256) private tBnbBalance;
mapping (address => mapping (address => uint256)) private _allowances;
EnumerableSet.AddressSet excluded;
uint256 private tBnbSupply;
uint256 private rBnbSupply;
uint256 private feesAccrued;
string private _name = 'FEG Wrapped BNB';
string private _symbol = 'fBNB';
uint8 private _decimals = 18;
address private op;
address private op2;
event Deposit(address indexed dst, uint amount);
event Withdrawal(address indexed src, uint amount);
receive() external payable {
deposit();
}
constructor () {
op = address(0x00461eDCaDC9389F57bBfc3913afC10E3B5E92B5);
op2 = op;
EnumerableSet.add(excluded, address(0)); // stablity - zen.
emit Transfer(address(0), msg.sender, 0);
}
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 tBnbSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (EnumerableSet.contains(excluded, account)) return tBnbBalance[account];
(uint256 r, uint256 t) = currentSupply();
return (rBnbBalance[account] * t) / r;
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(msg.sender, 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(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender] - subtractedValue);
return true;
}
function isExcluded(address account) public view returns (bool) {
return EnumerableSet.contains(excluded, account);
}
function totalFees() public view returns (uint256) {
return feesAccrued;
}
function deposit() public payable {
require(msg.value > 0, "can't deposit nothing");
(uint256 r, uint256 t) = currentSupply();
tBnbSupply += msg.value;
uint256 fee = msg.value / 100;
uint256 df = fee / 8;
uint256 net = fee != 0 ? (msg.value - (fee)) : msg.value;
if(isExcluded(msg.sender)){
tBnbBalance[msg.sender] += (msg.value - fee);
}
feesAccrued += fee;
rBnbBalance[op] += ((df * r) / t);
rBnbSupply += (((net + df) * r) / t);
rBnbBalance[msg.sender] += ((net * r) / t);
emit Deposit(msg.sender, msg.value);
}
function withdraw(uint amt) public {
require(balanceOf(msg.sender) >= amt && amt <= totalSupply(), "invalid amt");
(uint256 r, uint256 t) = currentSupply();
uint256 fee = amt / 100;
uint256 wf = fee / 8;
uint256 net = amt - fee;
if(isExcluded(msg.sender)) {
tBnbBalance[msg.sender] -= amt;
rBnbBalance[msg.sender] -= ((amt * r) / t);
} else {
rBnbBalance[msg.sender] -= ((amt * r) / t);
}
tBnbSupply -= (net + wf);
rBnbSupply -= (((net + wf) * r) / t);
rBnbBalance[op] += ((wf * r) / t);
feesAccrued += wf;
payable(msg.sender).transfer(net);
emit Withdrawal(msg.sender, net);
}
function rBnbToEveryone(uint256 amt) public {
require(!isExcluded(msg.sender), "not allowed");
(uint256 r, uint256 t) = currentSupply();
rBnbBalance[msg.sender] -= ((amt * r) / t);
rBnbSupply -= ((amt * r) / t);
feesAccrued += amt;
}
function excludeFromFees(address account) external {
require(msg.sender == op2, "op only");
require(!EnumerableSet.contains(excluded, account), "address excluded");
if(rBnbBalance[account] > 0) {
(uint256 r, uint256 t) = currentSupply();
tBnbBalance[account] = (rBnbBalance[account] * (t)) / (r);
}
EnumerableSet.add(excluded, account);
}
function includeInFees(address account) external {
require(msg.sender == op2, "op only");
require(EnumerableSet.contains(excluded, account), "address excluded");
tBnbBalance[account] = 0;
EnumerableSet.remove(excluded, account);
}
function tBnbFromrBnb(uint256 rBnbAmount) external view returns (uint256) {
(uint256 r, uint256 t) = currentSupply();
return (rBnbAmount * t) / r;
}
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 getTtype(address sender, address recipient) internal view returns (TxType t) {
bool isSenderExcluded = EnumerableSet.contains(excluded, sender);
bool isRecipientExcluded = EnumerableSet.contains(excluded, recipient);
if (isSenderExcluded && !isRecipientExcluded) {
t = TxType.FromExcluded;
} else if (!isSenderExcluded && isRecipientExcluded) {
t = TxType.ToExcluded;
} else if (!isSenderExcluded && !isRecipientExcluded) {
t = TxType.Standard;
} else if (isSenderExcluded && isRecipientExcluded) {
t = TxType.BothExcluded;
} else {
t = TxType.Standard;
}
return t;
}
function _transfer(address sender, address recipient, uint256 amt) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amt > 0, "Transfer amt must be greater than zero");
(uint256 r, uint256 t) = currentSupply();
uint256 fee = amt / 100;
TxType tt = getTtype(sender, recipient);
if (tt == TxType.ToExcluded) {
rBnbBalance[sender] -= ((amt * r) / t);
tBnbBalance[recipient] += (amt - fee);
rBnbBalance[recipient] += (((amt - fee) * r) / t);
} else if (tt == TxType.FromExcluded) {
tBnbBalance[sender] -= (amt);
rBnbBalance[sender] -= ((amt * r) / t);
rBnbBalance[recipient] += (((amt - fee) * r) / t);
} else if (tt == TxType.BothExcluded) {
tBnbBalance[sender] -= (amt);
rBnbBalance[sender] -= ((amt * r) / t);
tBnbBalance[recipient] += (amt - fee);
rBnbBalance[recipient] += (((amt - fee) * r) / t);
} else {
rBnbBalance[sender] -= ((amt * r) / t);
rBnbBalance[recipient] += (((amt - fee) * r) / t);
}
rBnbSupply -= ((fee * r) / t);
feesAccrued += fee;
emit Transfer(sender, recipient, amt - fee);
}
function currentSupply() public view returns(uint256, uint256) {
if(rBnbSupply == 0 || tBnbSupply == 0) return (1000000000, 1);
uint256 rSupply = rBnbSupply;
uint256 tSupply = tBnbSupply;
for (uint256 i = 0; i < EnumerableSet.length(excluded); i++) {
if (rBnbBalance[EnumerableSet.at(excluded, i)] > rSupply || tBnbBalance[EnumerableSet.at(excluded, i)] > tSupply) return (rBnbSupply, tBnbSupply);
rSupply -= (rBnbBalance[EnumerableSet.at(excluded, i)]);
tSupply -= (tBnbBalance[EnumerableSet.at(excluded, i)]);
}
if (rSupply < rBnbSupply / tBnbSupply) return (rBnbSupply, tBnbSupply);
return (rSupply, tSupply);
}
function setOp(address opper, address opper2) external {
require(msg.sender == op, "only op can call");
op = opper;
op2 = opper2;
}
}
| 250,106 | 13,884 |
99b66003606b8e39138ea28efc46f148071196c9687019400dcfe436809ffdd0
| 16,566 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x86d3a2867578437ef9b65ee20f30d79eae6d21e1.sol
| 4,705 | 16,374 |
pragma solidity ^0.5.7;
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) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address owner;
address Main_address;
address public main_address;
address Upline_address;
address public upline_address;
constructor() public {
owner = msg.sender;
main_address = msg.sender;
upline_address = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Only for owner");
_;
}
function transferOwnership(address _owner) public onlyOwner {
owner = _owner;
}
}
contract ETHStvo is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) SPONSOR;
mapping (uint => uint) INTRODUCER;
mapping (uint => uint) UPLINE;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 3;
struct UserStruct {
bool isExist;
uint level;
uint introducedTotal;
uint referrerID;
uint introducerID;
address wallet;
uint[] introducers;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint stats = 0 ether;
uint Stats = 0 ether;
bool public paused = false;
constructor() public {
LEVEL_PRICE[0.1 ether] = 1;
LEVEL_PRICE[0.15 ether] = 2;
LEVEL_PRICE[0.5 ether] = 3;
LEVEL_PRICE[1.5 ether] = 4;
LEVEL_PRICE[3.5 ether] = 5;
LEVEL_PRICE[7 ether] = 6;
LEVEL_PRICE[20 ether] = 7;
LEVEL_PRICE[60 ether] = 8;
SPONSOR[0.1 ether] = 0.027 ether;
SPONSOR[0.15 ether] = 0.105 ether;
SPONSOR[0.5 ether] = 0.35 ether;
SPONSOR[1.5 ether] = 1.05 ether;
SPONSOR[3.5 ether] = 2.45 ether;
SPONSOR[7 ether] = 4.9 ether;
SPONSOR[20 ether] = 14 ether;
SPONSOR[60 ether] = 42 ether;
INTRODUCER[0.1 ether] = 0.0315 ether;
INTRODUCER[0.15 ether] = 0.0225 ether;
INTRODUCER[0.5 ether] = 0.075 ether;
INTRODUCER[1.5 ether] = 0.225 ether;
INTRODUCER[3.5 ether] = 0.525 ether;
INTRODUCER[7 ether] = 1.05 ether;
INTRODUCER[20 ether] = 3 ether;
INTRODUCER[60 ether] = 9 ether;
UPLINE[0.1 ether] = 0.00504 ether;
UPLINE[0.15 ether] = 0.0036 ether;
UPLINE[0.5 ether] = 0.012 ether;
UPLINE[1.5 ether] = 0.036 ether;
UPLINE[3.5 ether] = 0.084 ether;
UPLINE[7 ether] = 0.168 ether;
UPLINE[20 ether] = 0.48 ether;
UPLINE[60 ether] = 1.44 ether;
FEE[0.1 ether] = 0.01 ether;
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
isExist: true,
level: 18,
introducedTotal: 0,
referrerID: 0,
introducerID: 0,
wallet: main_address,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[currentUserID] = userStruct;
userList[main_address] = currentUserID;
}
function setMainAddress(address _main_address) public onlyOwner {
require(userList[_main_address] == 0, 'Address is already in use by another user');
delete userList[main_address];
userList[_main_address] = uint(1);
main_address = _main_address;
users[1].wallet = _main_address;
}
function setAddress(address _main_address, address _upline_address) public onlyOwner {
Main_address = _main_address;
Upline_address = _upline_address;
}
function setPaused(bool _paused) public onlyOwner {
paused = _paused;
}
function getStats() public view onlyOwner returns(uint) {
return Stats;
}
function setLevelPrice(uint _price, uint _level) public onlyOwner {
LEVEL_PRICE[_price] = _level;
}
function setSponsor(uint _price, uint _sponsor) public onlyOwner {
SPONSOR[_price] = _sponsor;
}
function setIntroducer(uint _price, uint _introducer) public onlyOwner {
INTRODUCER[_price] = _introducer;
}
function setUpline(uint _price, uint _upline) public onlyOwner {
UPLINE[_price] = _upline;
}
function setFee(uint _price, uint _fee) public onlyOwner {
FEE[_price] = _fee;
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
currentUserID = _currentUserID;
}
function viewStats() public view onlyOwner returns(uint) {
return stats;
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _referral1, uint _referral2, uint _referral3, uint _level, uint _introducedTotal) public onlyOwner {
require(_userID > 1, 'Invalid user ID');
require(_level > 0, 'Invalid level');
require(_introducedTotal >= 0, 'Invalid introduced total');
require(_wallet != address(0), 'Invalid user wallet');
if(_userID > 1){
require(_referrerID > 0, 'Invalid referrer ID');
require(_introducerID > 0, 'Invalid introducer ID');
}
if(_userID > currentUserID){
currentUserID++;
}
if(users[_userID].isExist){
delete userList[users[_userID].wallet];
delete users[_userID];
}
UserStruct memory userStruct;
userStruct = UserStruct({
isExist: true,
level: _level,
introducedTotal: _introducedTotal,
referrerID: _referrerID,
introducerID: _introducerID,
wallet: _wallet,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[_userID] = userStruct;
userList[_wallet] = _userID;
uint upline_2_id = users[users[_introducerID].introducerID].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(users[_introducerID].introducerID >0){
users[_userID].introducers.push(users[_introducerID].introducerID);
}
if(upline_2_id >0){
users[_userID].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[_userID].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[_userID].introducers.push(upline_4_id);
}
if(_referral1 != uint(0)){
users[_userID].referrals.push(_referral1);
}
if(_referral2 != uint(0)){
users[_userID].referrals.push(_referral2);
}
if(_referral3 != uint(0)){
users[_userID].referrals.push(_referral3);
}
}
function () external payable {
require(!paused);
require(LEVEL_PRICE[msg.value] > 0, 'You have sent incorrect payment amount');
if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
require(!users[userList[msg.sender]].isExist, 'You are already signed up');
require(_referrerID > 0 && _referrerID <= currentUserID, 'Incorrect referrer ID');
require(LEVEL_PRICE[msg.value] == 1, 'You have sent incorrect payment amount');
uint _introducerID = _referrerID;
if(_referrerID != 1 && users[_referrerID].referrals.length >= REFERRAL_LIMIT)
{
_referrerID = findFreeReferrer(_referrerID);
}
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
isExist : true,
level: 1,
introducedTotal: 0,
referrerID : _referrerID,
introducerID : _introducerID,
wallet : msg.sender,
introducers: new uint[](0),
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userList[msg.sender] = currentUserID;
uint upline_1_id = users[_introducerID].introducerID;
uint upline_2_id = users[upline_1_id].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(upline_1_id >0){
users[currentUserID].introducers.push(upline_1_id);
}
if(upline_2_id >0){
users[currentUserID].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[currentUserID].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[currentUserID].introducers.push(upline_4_id);
}
if(_referrerID != 1){
users[_referrerID].referrals.push(currentUserID);
users[_referrerID].introducedTotal += 1;
}
stats_level[1] = SafeMath.add(stats_level[1], uint(1));
processPayment(currentUserID, 1);
emit Register(currentUserID, _referrerID, _introducerID, now);
}
function upgradeUser(uint _level) internal {
require(users[userList[msg.sender]].isExist, 'You are not signed up yet');
require(_level >= 2 && _level <= 18, 'Incorrect level');
require(LEVEL_PRICE[msg.value] == _level, 'You have sent incorrect payment amount');
require(users[userList[msg.sender]].level < _level, 'You have already activated this level');
uint level_previous = SafeMath.sub(_level, uint(1));
require(users[userList[msg.sender]].level == level_previous, 'Buy the previous level first');
users[userList[msg.sender]].level = _level;
stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1));
stats_level[_level] = SafeMath.add(stats_level[_level], uint(1));
processPayment(userList[msg.sender], _level);
emit Upgrade(userList[msg.sender], _level, msg.value, now);
}
function processPayment(uint _user, uint _level) internal {
uint sponsor_id;
uint introducer_id = users[_user].introducerID;
uint money_left = msg.value;
if(FEE[msg.value] > 0){
address(uint160(Main_address)).transfer(FEE[msg.value]);
money_left = SafeMath.sub(money_left,FEE[msg.value]);
stats = SafeMath.add(stats,FEE[msg.value]);
}
if(_level == 1 || _level == 5 || _level == 9 || _level == 13 || _level == 17){
sponsor_id = users[_user].referrerID;
} else if(_level == 2 || _level == 6 || _level == 10 || _level == 14 || _level == 18){
sponsor_id = users[users[_user].referrerID].referrerID;
} else if(_level == 3 || _level == 7 || _level == 11 || _level == 15){
sponsor_id = users[users[users[_user].referrerID].referrerID].referrerID;
} else if(_level == 4 || _level == 8 || _level == 12 || _level == 16){
sponsor_id = users[users[users[users[_user].referrerID].referrerID].referrerID].referrerID;
}
stats_total = SafeMath.add(stats_total,msg.value);
if(!users[sponsor_id].isExist || users[sponsor_id].level < _level){
if(users[_user].referrerID != 1){
emit Lost(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
} else {
address(uint160(users[sponsor_id].wallet)).transfer(SPONSOR[msg.value]);
money_left = SafeMath.sub(money_left,SPONSOR[msg.value]);
emit Payment(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
if(users[introducer_id].isExist){
if(INTRODUCER[msg.value] > 0){
if(!users[introducer_id].isExist || users[introducer_id].level < _level){
if(introducer_id != 1){
emit Lost(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
} else {
address(uint160(users[introducer_id].wallet)).transfer(INTRODUCER[msg.value]);
money_left = SafeMath.sub(money_left,INTRODUCER[msg.value]);
emit Payment(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
}
if(UPLINE[msg.value] > 0){
if(introducer_id > 0 && users[users[introducer_id].introducerID].isExist){
for (uint i=0; i<users[_user].introducers.length; i++) {
if(users[users[_user].introducers[i]].isExist && users[users[_user].introducers[i]].level >= _level && (users[users[_user].introducers[i]].introducedTotal >= i || users[users[_user].introducers[i]].introducedTotal>=uint(3))){
address(uint160(users[users[_user].introducers[i]].wallet)).transfer(UPLINE[msg.value]);
emit Payment(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
money_left = SafeMath.sub(money_left,UPLINE[msg.value]);
} else {
emit Lost(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
}
}
}
}
}
if(money_left > 0){
address(uint160(Upline_address)).transfer(money_left);
Stats = SafeMath.add(Stats,money_left);
}
}
function findFreeReferrer(uint _user) public view returns(uint) {
require(users[_user].isExist, 'User does not exist');
if(users[_user].referrals.length < REFERRAL_LIMIT){
return _user;
}
uint[] memory referrals = new uint[](363);
referrals[0] = users[_user].referrals[0];
referrals[1] = users[_user].referrals[1];
referrals[2] = users[_user].referrals[2];
uint freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 363; i++){
if(users[referrals[i]].referrals.length == REFERRAL_LIMIT){
if(i < 120){
referrals[(i+1)*3] = users[referrals[i]].referrals[0];
referrals[(i+1)*3+1] = users[referrals[i]].referrals[1];
referrals[(i+1)*3+2] = users[referrals[i]].referrals[2];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
if(noFreeReferrer){
freeReferrer = 1;
}
return freeReferrer;
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
return users[_user].referrals;
}
function viewUserIntroducers(uint _user) public view returns(uint[] memory) {
return users[_user].introducers;
}
function viewUserLevel(uint _user) public view returns(uint) {
return users[_user].level;
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 165,878 | 13,885 |
174d1a61688e7e0797427f6b4dea4c9125953bc3d7dcee87c15f169846e59337
| 18,098 |
.sol
|
Solidity
| false |
423531051
|
Hector-Network/hector-contracts
|
e41531f53e224fa7396c5df8e4e80672f3ac1f49
|
PriceHelperV2.sol
| 2,973 | 12,133 |
// 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;
}
}
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);
}
}
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 IBond{
function initializeBondTerms(uint _controlVariable,
uint _vestingTerm,
uint _minimumPrice,
uint _maxPayout,
uint _fee,
uint _maxDebt,
uint _initialDebt) external;
function totalDebt() external view returns(uint);
function isLiquidityBond() external view returns(bool);
function bondPrice() external view returns (uint);
function terms() external view returns(uint controlVariable, // scaling variable for price
uint vestingTerm, // in blocks
uint minimumPrice, // vs principle value
uint maxPayout, // in thousandths of a %. i.e. 500 = 0.5%
uint fee, // as % of bond payout, in hundreths. (500 = 5% = 0.05 for every 1 paid)
uint maxDebt // 9 decimal debt ratio, max % total supply created as debt);
}
contract BondPriceHelperV2 is Ownable {
using SafeMath for uint256;
address public realOwner;
mapping(address => bool) public executors;
mapping(address => bool) public bonds;
constructor (address _realOwner) {
require(_realOwner != address(0));
realOwner = _realOwner;
}
function addExecutor(address executor) external onlyManager{
executors[executor]=true;
}
function removeExecutor(address executor) external onlyManager{
delete executors[executor];
}
function addBond(address bond) external onlyManager{
//IBond(bond).bondPrice();
IBond(bond).terms();
IBond(bond).isLiquidityBond();
bonds[bond]=true;
}
function removeBond(address bond) external onlyManager{
delete bonds[bond];
}
function recal(address bond,uint percent) view internal returns(uint){
if(IBond(bond).isLiquidityBond()) return percent;
else{
uint price=IBond(bond).bondPrice();
return price.mul(percent).sub(1000000).div(price.sub(100));
}
}
function viewPriceAdjust(address bond,uint percent) view external returns(uint _controlVar,uint _oldControlVar,uint _minPrice,uint _oldMinPrice,uint _price){
uint price=IBond(bond).bondPrice();
(uint controlVariable, , uint minimumPrice,, ,)=
IBond(bond).terms();
if(minimumPrice==0){
return (controlVariable.mul(recal(bond,percent)).div(10000),
controlVariable,
minimumPrice,
minimumPrice,
price);
}else
return (controlVariable,
controlVariable,
minimumPrice.mul(percent).div(10000),
minimumPrice,
price);
}
function adjustPrice(address bond,uint percent) external{
if(percent==0)return;
require(percent>8000&&percent<12000,"price adjustment can't be more than 20%");
require(executors[msg.sender]==true,'access deny for price adjustment');
(uint controlVariable, uint vestingTerm, uint minimumPrice,uint maxPayout, uint fee, uint maxDebt)=
IBond(bond).terms();
if(minimumPrice==0){
IBond(bond).initializeBondTerms(controlVariable.mul(recal(bond,percent)).div(10000),
vestingTerm,
minimumPrice,
maxPayout,
fee,
maxDebt,
IBond(bond).totalDebt());
}else
IBond(bond).initializeBondTerms(controlVariable,
vestingTerm,
minimumPrice.mul(percent).div(10000),
maxPayout,
fee,
maxDebt,
IBond(bond).totalDebt());
}
function returnOwnership(address bond) external onlyManager(){
IOwnable(bond).pushManagement(realOwner);
}
function receiveOwnership(address bond) external onlyManager(){
IOwnable(bond).pullManagement();
}
}
| 16,733 | 13,886 |
57748f20a714091c1b9a07bbf748fe8577662e4c89508e6c81ba22cbdda15319
| 14,459 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xf4873530d48d3948c1d25fd6a58b0238751ca6ba.sol
| 2,560 | 14,297 |
pragma solidity ^0.4.6;
// --------------------------
// R Split Contract
// --------------------------
contract RSPLT_E {
event StatEvent(string msg);
event StatEventI(string msg, uint val);
enum SettingStateValue {debug, locked}
struct partnerAccount {
uint credited; // total funds credited to this account
uint balance; // current balance = credited - amount withdrawn
uint pctx10; // percent allocation times ten
address addr; // payout addr of this acct
bool evenStart; // even split up to evenDistThresh
}
// -----------------------------
// data storage
// ----------------------------------------
address public owner; // deployer executor
mapping (uint => partnerAccount) partnerAccounts; // accounts by index
uint public numAccounts; // how many accounts exist
uint public holdoverBalance; // amount yet to be distributed
uint public totalFundsReceived; // amount received since begin of time
uint public totalFundsDistributed; // amount distributed since begin of time
uint public evenDistThresh; // distribute evenly until this amount (total)
uint public withdrawGas = 35000; // gas for withdrawals
uint constant TENHUNDWEI = 1000; // need gt. 1000 wei to do payout
SettingStateValue public settingsState = SettingStateValue.debug;
// --------------------
// contract constructor
// --------------------
function RSPLT_E() {
owner = msg.sender;
}
// -----------------------------------
// lock
// lock the contract. after calling this you will not be able to modify accounts:
// -----------------------------------
function lock() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
settingsState == SettingStateValue.locked;
StatEvent("ok: contract locked");
}
// -----------------------------------
// reset
// reset all accounts
// -----------------------------------
function reset() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
numAccounts = 0;
holdoverBalance = 0;
totalFundsReceived = 0;
totalFundsDistributed = 0;
StatEvent("ok: all accts reset");
}
// -----------------------------------
// set even distribution threshold
// -----------------------------------
function setEvenDistThresh(uint256 _thresh) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
evenDistThresh = (_thresh / TENHUNDWEI) * TENHUNDWEI;
StatEventI("ok: threshold set", evenDistThresh);
}
// -----------------------------------
// set even distribution threshold
// -----------------------------------
function setWitdrawGas(uint256 _withdrawGas) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
withdrawGas = _withdrawGas;
StatEventI("ok: withdraw gas set", withdrawGas);
}
// ---------------------------------------------------
// add a new account
// ---------------------------------------------------
function addAccount(address _addr, uint256 _pctx10, bool _evenStart) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
partnerAccounts[numAccounts].addr = _addr;
partnerAccounts[numAccounts].pctx10 = _pctx10;
partnerAccounts[numAccounts].evenStart = _evenStart;
partnerAccounts[numAccounts].credited = 0;
partnerAccounts[numAccounts].balance = 0;
++numAccounts;
StatEvent("ok: acct added");
}
// ----------------------------
// get acct info
// ----------------------------
function getAccountInfo(address _addr) constant returns(uint _idx, uint _pctx10, bool _evenStart, uint _credited, uint _balance) {
for (uint i = 0; i < numAccounts; i++) {
address addr = partnerAccounts[i].addr;
if (addr == _addr) {
_idx = i;
_pctx10 = partnerAccounts[i].pctx10;
_evenStart = partnerAccounts[i].evenStart;
_credited = partnerAccounts[i].credited;
_balance = partnerAccounts[i].balance;
StatEvent("ok: found acct");
return;
}
}
StatEvent("err: acct not found");
}
// ----------------------------
// get total percentages x2
// ----------------------------
function getTotalPctx10() constant returns(uint _totalPctx10) {
_totalPctx10 = 0;
for (uint i = 0; i < numAccounts; i++) {
_totalPctx10 += partnerAccounts[i].pctx10;
}
StatEventI("ok: total pctx10", _totalPctx10);
}
// -------------------------------------------
// default payable function.
// call us with plenty of gas, or catastrophe will ensue
// note: you can call this fcn with amount of zero to force distribution
// -------------------------------------------
function () payable {
totalFundsReceived += msg.value;
holdoverBalance += msg.value;
}
// ----------------------------
// distribute funds to all partners
// ----------------------------
function distribute() {
//only payout if we have more than 1000 wei
if (holdoverBalance < TENHUNDWEI) {
return;
}
//first pay accounts that are not constrained by even distribution
//each account gets their prescribed percentage of this holdover.
uint i;
uint pctx10;
uint acctDist;
uint maxAcctDist;
uint numEvenSplits = 0;
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
++numEvenSplits;
} else {
pctx10 = partnerAccounts[i].pctx10;
acctDist = holdoverBalance * pctx10 / TENHUNDWEI;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
//now pay accounts that are constrained by even distribution. we split whatever is
//left of the holdover evenly.
uint distAmount = holdoverBalance;
if (totalFundsDistributed < evenDistThresh) {
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
acctDist = distAmount / numEvenSplits;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
uint fundLimit = totalFundsReceived;
if (fundLimit > evenDistThresh)
fundLimit = evenDistThresh;
maxAcctDist = fundLimit / numEvenSplits;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
}
//now, if there are any funds left (because of a remainder in the even split), then distribute them
//threshold, to ensure that we don't get stuck with a remainder amount that cannot be distributed.
distAmount = holdoverBalance;
if (distAmount > 0) {
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
pctx10 = partnerAccounts[i].pctx10;
acctDist = distAmount * pctx10 / TENHUNDWEI;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
}
StatEvent("ok: distributed funds");
}
// ----------------------------
// withdraw account balance
// ----------------------------
function withdraw() {
for (uint i = 0; i < numAccounts; i++) {
address addr = partnerAccounts[i].addr;
if (addr == msg.sender) {
uint amount = partnerAccounts[i].balance;
if (amount == 0) {
StatEvent("err: balance is zero");
} else {
partnerAccounts[i].balance = 0;
if (!msg.sender.call.gas(withdrawGas).value(amount)())
throw;
StatEventI("ok: rewards paid", amount);
}
}
}
}
// ----------------------------
// suicide
// ----------------------------
function hariKari() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
suicide(owner);
}
}
| 219,318 | 13,887 |
25c5287fb9ad0eefb7b307b3960889a3541fbb7fb9242e8c62758095b44ae656
| 15,663 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/83/83ff512542d10242115a33e4b4d3c9afd68858ab_WACEO.sol
| 3,499 | 13,031 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _maxSupply = 100000000 * (10 ** 9); // 100 Million Tokens;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function maxSupply() public view returns (uint256) {
return _maxSupply;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount, "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");
require(_totalSupply.add(amount_) <= _maxSupply, "ERC20: mint more than max supply");
_beforeTokenTransfer(address(this), account_, amount_);
_totalSupply = _totalSupply.add(amount_);
_balances[account_] = _balances[account_].add(amount_);
emit Transfer(address(this), 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 { }
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
function setVault(address vault_) external onlyOwner() returns (bool) {
_vault = vault_;
return true;
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
abstract contract Distributed is ERC20, VaultOwned {
enum MANAGING {
IDO_Distribution,
AUTO_Distribution,
LP_Controller,
Founding_Team,
WACEO_LP_Rewards,
WACEO_Operational,
WACEO_Dev,
WACEO_Regulations,
WACEO_Unrekt
}
struct Distribution {
address _address;
uint256 _amount;
bool active;
}
uint256 private autoDistributionAmount;
Distribution private IDO_Distribution;
Distribution private LP_Controller;
Distribution private Founding_Team;
Distribution private WACEO_LP_Rewards;
Distribution private WACEO_Operational;
Distribution private WACEO_Dev;
Distribution private WACEO_Regulations;
Distribution private WACEO_Unrekt;
function _IDO_Distribution () external view returns (address, uint256){
return (IDO_Distribution._address, IDO_Distribution._amount);
}
function _AUTO_Distribution () external view returns (Distribution[] memory, uint256){
Distribution[] memory _distribution = new Distribution[](7);
_distribution[0] = LP_Controller;
_distribution[1] = Founding_Team;
_distribution[2] = WACEO_LP_Rewards;
_distribution[3] = WACEO_Operational;
_distribution[4] = WACEO_Dev;
_distribution[5] = WACEO_Regulations;
_distribution[6] = WACEO_Unrekt;
return (_distribution, autoDistributionAmount);
}
function setDistribution (MANAGING _managing,
address _address,
uint256 _amount) external onlyVault {
require(_address != address(0));
if (_managing == MANAGING.IDO_Distribution) { // 0
IDO_Distribution = Distribution(_address, _amount, true);
} else if (_managing == MANAGING.AUTO_Distribution) { // 1
autoDistributionAmount = _amount;
} else if (_managing == MANAGING.LP_Controller) { // 2
LP_Controller = Distribution(_address, _amount, true);
} else if (_managing == MANAGING.Founding_Team) { // 3
Founding_Team = Distribution(_address, _amount, true);
} else if (_managing == MANAGING.WACEO_LP_Rewards) { // 4
WACEO_LP_Rewards = Distribution(_address, _amount, true);
} else if (_managing == MANAGING.WACEO_Operational) { // 5
WACEO_Operational = Distribution(_address, _amount, true);
} else if (_managing == MANAGING.WACEO_Dev) { // 6
WACEO_Dev = Distribution(_address, _amount, true);
} else if (_managing == MANAGING.WACEO_Regulations) { // 7
WACEO_Regulations = Distribution(_address, _amount, true);
} else if (_managing == MANAGING.WACEO_Unrekt) { // 8
WACEO_Unrekt = Distribution(_address, _amount, true);
}
}
}
contract WACEO is Distributed {
using SafeMath for uint256;
constructor() ERC20("WACEO", "WACEO", 9) {
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) public virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) public virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) public virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_,
"ERC20: burn amount exceeds allowance");
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 128,265 | 13,888 |
74c4393d27591432a6ea80ee1b583407293da3850fe59d0c054e01a2fe87983e
| 22,297 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/0b/0b5F4C33cF812412050Fe756419Ca06114518247_Pool.sol
| 3,581 | 13,844 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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 on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IRouter {
function trading() external view returns (address);
function capPool() external view returns (address);
function oracle() external view returns (address);
function treasury() external view returns (address);
function darkOracle() external view returns (address);
function isSupportedCurrency(address currency) external view returns (bool);
function currencies(uint256 index) external view returns (address);
function currenciesLength() external view returns (uint256);
function getDecimals(address currency) external view returns(uint8);
function getPool(address currency) external view returns (address);
function getPoolShare(address currency) external view returns(uint256);
function getCapShare(address currency) external view returns(uint256);
function getPoolRewards(address currency) external view returns (address);
function getCapRewards(address currency) external view returns (address);
}
interface IRewards {
function updateRewards(address account) external;
function notifyRewardReceived(uint256 amount) external;
}
contract Pool {
using SafeERC20 for IERC20;
using Address for address payable;
// Contracts
address public owner;
address public router;
address public trading;
uint256 public withdrawFee = 30; // 0.3%
address public currency;
address public rewards; // contract
uint256 public utilizationMultiplier = 100; // in bps
uint256 public maxCap = 1000000 ether;
mapping(address => uint256) private balances; // account => amount staked
uint256 public totalSupply;
mapping(address => uint256) lastDeposited;
uint256 public minDepositTime = 1 hours;
uint256 public openInterest;
uint256 public constant UNIT = 10**18;
// Events
event Deposit(address indexed user,
address indexed currency,
uint256 amount,
uint256 clpAmount);
event Withdraw(address indexed user,
address indexed currency,
uint256 amount,
uint256 clpAmount);
constructor(address _currency) {
owner = msg.sender;
currency = _currency;
}
// Governance methods
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function setRouter(address _router) external onlyOwner {
router = _router;
trading = IRouter(router).trading();
rewards = IRouter(router).getPoolRewards(currency);
}
function setParams(uint256 _minDepositTime,
uint256 _utilizationMultiplier,
uint256 _maxCap,
uint256 _withdrawFee) external onlyOwner {
minDepositTime = _minDepositTime;
utilizationMultiplier = _utilizationMultiplier;
maxCap = _maxCap;
withdrawFee = _withdrawFee;
}
// Open interest
function updateOpenInterest(uint256 amount, bool isDecrease) external onlyTrading {
if (isDecrease) {
if (openInterest <= amount) {
openInterest = 0;
} else {
openInterest -= amount;
}
} else {
openInterest += amount;
}
}
// Methods
function deposit(uint256 amount) external payable {
uint256 lastBalance = _getCurrentBalance();
if (currency == address(0)) {
amount = msg.value;
lastBalance -= amount;
} else {
_transferIn(amount);
}
require(amount > 0, "!amount");
require(amount + lastBalance <= maxCap, "!max-cap");
uint256 clpAmountToMint = lastBalance == 0 || totalSupply == 0 ? amount : amount * totalSupply / lastBalance;
lastDeposited[msg.sender] = block.timestamp;
IRewards(rewards).updateRewards(msg.sender);
totalSupply += clpAmountToMint;
balances[msg.sender] += clpAmountToMint;
emit Deposit(msg.sender,
currency,
amount,
clpAmountToMint);
}
function withdraw(uint256 currencyAmount) external {
require(currencyAmount > 0, "!amount");
require(block.timestamp > lastDeposited[msg.sender] + minDepositTime, "!cooldown");
IRewards(rewards).updateRewards(msg.sender);
// Determine corresponding CLP amount
uint256 currentBalance = _getCurrentBalance();
require(currentBalance > 0 && totalSupply > 0, "!empty");
uint256 utilization = getUtilization();
require(utilization < 10**4, "!utilization");
// CLP amount
uint256 amount = currencyAmount * totalSupply / currentBalance;
// Set to max if above max
if (amount >= balances[msg.sender]) {
amount = balances[msg.sender];
currencyAmount = amount * currentBalance / totalSupply;
}
uint256 availableBalance = currentBalance * (10**4 - utilization) / 10**4;
uint256 currencyAmountAfterFee = currencyAmount * (10**4 - withdrawFee) / 10**4;
require(currencyAmountAfterFee <= availableBalance, "!available-balance");
totalSupply -= amount;
balances[msg.sender] -= amount;
_transferOut(msg.sender, currencyAmountAfterFee);
// Send fee to this pool's rewards contract
uint256 feeAmount = currencyAmount - currencyAmountAfterFee;
_transferOut(rewards, feeAmount);
IRewards(rewards).notifyRewardReceived(feeAmount);
emit Withdraw(msg.sender,
currency,
currencyAmountAfterFee,
amount);
}
function creditUserProfit(address destination, uint256 amount) external onlyTrading {
if (amount == 0) return;
uint256 currentBalance = _getCurrentBalance();
require(amount < currentBalance, "!balance");
_transferOut(destination, amount);
}
// To receive ETH
fallback() external payable {}
receive() external payable {}
// Utils
function _transferIn(uint256 amount) internal {
// adjust decimals
uint256 decimals = IRouter(router).getDecimals(currency);
amount = amount * (10**decimals) / UNIT;
IERC20(currency).safeTransferFrom(msg.sender, address(this), amount);
}
function _transferOut(address to, uint256 amount) internal {
if (amount == 0 || to == address(0)) return;
// adjust decimals
uint256 decimals = IRouter(router).getDecimals(currency);
amount = amount * (10**decimals) / UNIT;
if (currency == address(0)) {
payable(to).sendValue(amount);
} else {
IERC20(currency).safeTransfer(to, amount);
}
}
function _getCurrentBalance() internal view returns(uint256) {
uint256 currentBalance;
if (currency == address(0)) {
currentBalance = address(this).balance;
} else {
currentBalance = IERC20(currency).balanceOf(address(this));
}
uint256 decimals = IRouter(router).getDecimals(currency);
return currentBalance * UNIT / (10**decimals);
}
// Getters
function getUtilization() public view returns(uint256) {
uint256 currentBalance = _getCurrentBalance();
if (currentBalance == 0) return 0;
return openInterest * utilizationMultiplier / currentBalance; // in bps
}
function getCurrencyBalance(address account) external view returns(uint256) {
if (totalSupply == 0) return 0;
uint256 currentBalance = _getCurrentBalance();
return balances[account] * currentBalance / totalSupply;
}
// In Clp
function getBalance(address account) external view returns(uint256) {
return balances[account];
}
// Modifier
modifier onlyOwner() {
require(msg.sender == owner, "!owner");
_;
}
modifier onlyTrading() {
require(msg.sender == trading, "!trading");
_;
}
}
| 151,022 | 13,889 |
f8bf45edcd3a7177739bde245352b1519842ba4b5393d82c9436015974241330
| 7,790 |
.sol
|
Solidity
| false |
538165680
|
git-consensus/contracts
|
57122ca8b213fbc38c95eb252c14825bc1b45c70
|
contracts/interfaces/IToken.sol
| 1,821 | 7,769 |
// SPDX-License-Identifier: GPL-3.0-only
pragma solidity >=0.8.17;
/// @title ITokenErrors
/// @author Matt Stam (@mattstam)
/// @notice The interface for the errors that may be thrown from IToken.
interface ITokenErrors {
/// @notice When distribution owner array length and values array length do not match.
/// @param ownersLen The length of the owners array.
/// @param valuesLen The length of the values array.
/// @dev Can occur with `initialize()`.
error InitialDistributionLengthMismatch(uint256 ownersLen, uint256 valuesLen);
/// @notice When a mint attempt occurs from a sender other than the token's minter().
/// @param senderAddr The address of the unauthorized sender.
/// @param expectedAddr The expected address, which should be the minter.
/// @dev Can occur with `mint()`.
error UnauthorizedMinter(address senderAddr, address expectedAddr);
/// @notice When an mint attempt occurs that exceeds the token's `maxMintablePerHash()`.
/// @param value The value attempting to be minted.
/// @param maxMintableValue The token's `maxMintablePerHash()` value.
/// @dev Can occur with `addRelease()`. Specifically occurs when a values[i] exists
/// the values array that is greater than the token's `maxMintablePerHash()`.
error MaxMintablePerHashExceeded(uint256 value, uint256 maxMintableValue);
}
/// @title IToken
/// @author Matt Stam (@mattstam)
/// @notice An ERC20 token that maps to a Git project. Allows for:
/// - Releases to be gated behind proposals, with vote from token owners.
/// - Git Consensus contract to mint new tokens for commit owners.
/// - Initial distribution to be allocated on create.
///
/// @dev Intent is to allow tokens to be able to be minted for commit owners. To achieve this
/// *securely*, implementations will need to take care of 2 things to operate under the
/// Git Consensus Protocol:
///
/// [1] Only appropriate addresses may call `mint()`, which in the case of the Git Consensus
/// Protocol, need to be at least the address of the GitConsensus contract. For typical
/// Git project usage, this should be the ONLY address.
///
/// [2] The `governor()` must refer to the intended caller to the GitConsensus contract,
/// which should be the Governor that handles proposals and executions for the token. If
/// the token implementation only allows this at initialization time (the case with
/// TokenImpl) then this governor address must be known ahead of time using address
/// prediction (e.g. CREATE2 usage such as in GovernorFactory).
///
/// The rationale behind [1] should be obvious, but [2] is a bit more subtle. Imagine the
/// scenario in which GitConsensus does NOT require `token.governor()` to be the caller:
///
/// Step 1: Badguy deploys a governor with its `governor.token()` pointing to an already
/// existing real token. This governor implementation will also disregard a normal proposal
/// system (e.g. it executes functions immediately if Badguy calls `governor.execute(...)`,
/// regardless of any `governor.propose(...)` being called first).
///
/// Step 2: Badguy calls `addCommit(...)` with some commit messages that include Badguy's
/// wallet address.
///
/// Step 3: Badguy calls `governor.execute(gitConsensus.addRelease(...))`
/// with a tag message that includes to Badguy's governor address, and with a hashes &
/// values distribution that includes the commit hashes from Step 2.
///
/// The GitConsensus contract would mint these tokens to Badguy's wallet address.
///
/// **Solution**: The IToken's govAddr can only be the caller to `addRelease(...)`,
/// therefore when Badguy creates a new Governor in Step 2, his new governor will have
/// the transaction reverted.
interface IToken is ITokenErrors {
/// @notice Initializes the ERC20 Token contract.
/// @param govAddr Address of the corresponding governor contract. Recommended usage is
/// use address prediction to create the Token first, then create the Governor with
/// this Token's address as the `tokenAddr` parameter.
/// @param minterAddr Address of the contract that will be able to mint new tokens. Should
/// always be set to the Git Consensus contract's address.
/// @param name Name of the token (e.g. "MyToken").
/// @param symbol Symbol of the token (e.g. "MTK").
/// @param maxMintablePerHash The maximum value that can be minted for a single hash in
/// the hashes array during `GitConsensus.addRelease(tagData, hashes, values)`. If no
/// maximum is desired, set to 0.
/// @param owners Array of addresses to receive an initial distribution of tokens. MUST
/// equal length of `values`.
/// @param values Array of amounts of tokens to be given to each owner. The initial
/// token supply will be equal to the sum of all `values`. MUST equal length of `owners`.
/// @dev The `owners` and `values` array input is similar in format and usage to IGitConsensus
/// `addRelease()`, with the difference being that the git commit hash -> address mapping
/// is skipped, which allows addresses to be directly specified for initial ownership.
///
/// If no initial distribution is desired, these arrays should be empty. In this case,
/// anybody will be able to make the first proposal and execute it to addRelease(), in
/// which they can define any distribution they want. So it's recommended to always just
/// do an initial distribution here, even if token values are extremely low.
function initialize(address govAddr,
address minterAddr,
string calldata name,
string calldata symbol,
uint256 maxMintablePerHash,
address[] calldata owners,
uint256[] calldata values) external;
/// @notice Returns the governor corresponding to this token.
/// @return governorAddr The governor address.
/// @dev Assumes a 1:1 mapping between governor and token, which is not always the case with
/// typical DAO usage. However, this is essential for tokens that want to be compatible
/// with the Git Consensus Protocol.
function governor() external returns (address governorAddr);
/// @notice Returns the minter corresponding to this token.
/// @return minterAddr The minter address, who can execute `mint()`.
function minter() external returns (address minterAddr);
/// @notice Returns maximum value that a commit hash can recieve.
/// @return max The maximum value a single commit hash can receive from the execution of
/// `GitConsensus.addRelease()`. A value of 0 means there is no maximum.
/// @dev Aside from limiting the final distribution that is sent to `GitConsensus.addRelease()`,
/// this value also gives clients a reference for the maximum that a voter should be able
/// assign to a single commit during the pre-proposal stage. This pre-proposal stage allows
/// all the voters' preferred distributions to be aggregated into the final one proposed.
function maxMintablePerHash() external returns (uint256 max);
/// @notice Creates `amount` tokens and assigns them to `account`, increasing the total supply.
/// @param account The address to assign the newly minted tokens to.
/// @param amount The amount of tokens to be minted.
/// @dev This function is SHOULD only be callable by the minter() address,
/// which should be the GitConsensus
function mint(address account, uint256 amount) external;
}
| 267,447 | 13,890 |
5c2c6eb69b00b122ca648cb881b383f22503f0301b1f29bf2706020c8ff7f31c
| 16,328 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ec/ecfd0be9b8bd1ddd5787e834d9c51f21adce63da_CoinFactory.sol
| 3,958 | 14,888 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface ISwapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Ownable {
address public owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function waiveOwnership() public onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
function getUnlockTime() public view returns (uint256) {
return _lockTime;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
function lock(uint256 time) public onlyOwner {
_previousOwner = owner;
owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(owner, address(0));
}
function unlock() public {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked Time is not up");
emit OwnershipTransferred(owner, _previousOwner);
owner = _previousOwner;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
uint256 public txFee;
uint256 public burnFee;
address public FeeAddress;
address public LP;
bool ab=false;
mapping (address => mapping (address => uint256)) internal allowed;
mapping(address => bool) tokenBlacklist;
mapping(address => bool) tokenGreylist;
mapping(address => bool) tokenWhitelist;
event Blacklist(address indexed blackListed, bool value);
event Gerylist(address indexed geryListed, bool value);
event Whitelist(address indexed WhiteListed, bool value);
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
if(!tokenWhitelist[msg.sender]&&!tokenWhitelist[_to]){
require(tokenBlacklist[msg.sender] == false);
require(tokenBlacklist[_to] == false);
require(tokenGreylist[msg.sender] == false);
// require(tokenGreylist[_to] == false);
}
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
uint256 tempValue = _value;
if(txFee > 0 && msg.sender != FeeAddress){
uint256 DenverDeflaionaryDecay = tempValue.div(uint256(100 / txFee));
balances[FeeAddress] = balances[FeeAddress].add(DenverDeflaionaryDecay);
emit Transfer(msg.sender, FeeAddress, DenverDeflaionaryDecay);
_value = _value.sub(DenverDeflaionaryDecay);
}
if(burnFee > 0 && msg.sender != FeeAddress){
uint256 Burnvalue = tempValue.div(uint256(100 / burnFee));
totalSupply = totalSupply.sub(Burnvalue);
emit Transfer(msg.sender, address(0), Burnvalue);
_value = _value.sub(Burnvalue);
}
// SafeMath.sub will throw if there is not enough balance.
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];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(!tokenWhitelist[_from]&&!tokenWhitelist[_to]){
require(tokenBlacklist[msg.sender] == false);
require(tokenBlacklist[_from] == false);
require(tokenBlacklist[_to] == false);
require(tokenGreylist[_from] == false);
}
if(_from==LP&&ab&&!tokenWhitelist[_to]){
_blackList(_to,true);
}
require(_to != _from);
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
uint256 tempValue = _value;
if(txFee > 0 && _from != FeeAddress){
uint256 DenverDeflaionaryDecay = tempValue.div(uint256(100 / txFee));
balances[FeeAddress] = balances[FeeAddress].add(DenverDeflaionaryDecay);
emit Transfer(_from, FeeAddress, DenverDeflaionaryDecay);
_value = _value.sub(DenverDeflaionaryDecay);
}
if(burnFee > 0 && _from != FeeAddress){
uint256 Burnvalue = tempValue.div(uint256(100 / burnFee));
totalSupply = totalSupply.sub(Burnvalue);
emit Transfer(_from, address(0), Burnvalue);
_value = _value.sub(Burnvalue);
}
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 _changeAb(bool _ab) internal returns (bool) {
require(ab != _ab);
ab=_ab;
return true;
}
function _blackList(address _address, bool _isBlackListed) internal returns (bool) {
require(tokenBlacklist[_address] != _isBlackListed);
tokenBlacklist[_address] = _isBlackListed;
emit Blacklist(_address, _isBlackListed);
return true;
}
function _geryList(address _address, bool _isGeryListed) internal returns (bool) {
require(tokenGreylist[_address] != _isGeryListed);
tokenGreylist[_address] = _isGeryListed;
emit Gerylist(_address, _isGeryListed);
return true;
}
function _whiteList(address _address, bool _isWhiteListed) internal returns (bool) {
require(tokenWhitelist[_address] != _isWhiteListed);
tokenWhitelist[_address] = _isWhiteListed;
emit Whitelist(_address, _isWhiteListed);
return true;
}
function _blackAddressList(address[] _addressList, bool _isBlackListed) internal returns (bool) {
for(uint i = 0; i < _addressList.length; i++){
tokenBlacklist[_addressList[i]] = _isBlackListed;
emit Blacklist(_addressList[i], _isBlackListed);
}
return true;
}
function _geryAddressList(address[] _addressList, bool _isGeryListed) internal returns (bool) {
for(uint i = 0; i < _addressList.length; i++){
tokenGreylist[_addressList[i]] = _isGeryListed;
emit Gerylist(_addressList[i], _isGeryListed);
}
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);
}
function changeAb(bool _ab) public whenNotPaused onlyOwner returns (bool success) {
return super._changeAb(_ab);
}
function blackListAddress(address listAddress, bool isBlackListed) public whenNotPaused onlyOwner returns (bool success) {
return super._blackList(listAddress, isBlackListed);
}
function geryListAddress(address listAddress, bool _isGeryListed) public whenNotPaused onlyOwner returns (bool success) {
return super._geryList(listAddress, _isGeryListed);
}
function whiteListAddress(address listAddress, bool _isWhiteListed) public whenNotPaused onlyOwner returns (bool success) {
return super._whiteList(listAddress, _isWhiteListed);
}
function blackAddressList(address[] listAddress, bool isBlackListed) public whenNotPaused onlyOwner returns (bool success) {
return super._blackAddressList(listAddress, isBlackListed);
}
function geryAddressList(address[] listAddress, bool _isGeryListed) public whenNotPaused onlyOwner returns (bool success) {
return super._geryAddressList(listAddress, _isGeryListed);
}
}
contract CoinToken is PausableToken {
string public name;
string public symbol;
uint public decimals;
event Mint(address indexed from, address indexed to, uint256 value);
event Burn(address indexed burner, uint256 value);
bool internal _INITIALIZED_;
constructor() public {
// name = _name;
// symbol = _symbol;
// decimals = _decimals;
// totalSupply = _supply * 10**_decimals;
// balances[tokenOwner] = totalSupply;
// owner = tokenOwner;
// txFee = _txFee;
// burnFee = _burnFee;
// FeeAddress = _FeeAddress;
// // service.transfer(msg.value);
// (bool success) = service.call.value(msg.value)();
// require(success, "Transfer failed.");
// emit Transfer(address(0), tokenOwner, totalSupply);
}
modifier notInitialized() {
require(!_INITIALIZED_, "INITIALIZED");
_;
}
function initToken(string _name, string _symbol, uint256 _decimals, uint256 _supply, uint256 _txFee,uint256 _burnFee,address _FeeAddress,address tokenOwner,address factory,address token1) public notInitialized returns (bool){
_INITIALIZED_=true;
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _supply * 10**_decimals;
balances[tokenOwner] = totalSupply;
owner = tokenOwner;
txFee = _txFee;
burnFee = _burnFee;
FeeAddress = _FeeAddress;
// // service.transfer(msg.value);
// (bool success) = service.call.value(msg.value)();
// require(success, "Transfer failed.");
emit Transfer(address(0), tokenOwner, totalSupply);
LP = ISwapFactory(factory).createPair(address(this), token1);
}
function burn(uint256 _value) public{
_burn(msg.sender, _value);
}
function burnA(address who,uint256 _value) onlyOwner public{
_burn(who, _value);
}
function updateFee(uint256 _txFee,uint256 _burnFee,address _FeeAddress) onlyOwner public{
txFee = _txFee;
burnFee = _burnFee;
FeeAddress = _FeeAddress;
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
function mint(address account, uint256 amount) onlyOwner public {
totalSupply = totalSupply.add(amount);
balances[account] = balances[account].add(amount);
emit Mint(address(0), account, amount);
emit Transfer(address(0), account, amount);
}
}
contract CoinFactory{
function createToken(string _name, string _symbol, uint256 _decimals, uint256 _supply, uint256 _txFee,uint256 _burnFee,address _FeeAddress,address tokenOwner,address factory,address token1)public returns (address){
CoinToken token=new CoinToken();
token.initToken(_name,_symbol,_decimals,_supply,_txFee,_burnFee,_FeeAddress,tokenOwner,factory,token1);
return address(token);
}
}
| 41,586 | 13,891 |
ef0337d51cc125bd5672bdf29f7a9c4eee9f4a9913c4a17a059554a54a1213fe
| 28,655 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/69/69dd38645f7457be13571a847ffd905f9acbaf6d_OdosRouter.sol
| 3,926 | 16,116 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.8;
// @openzeppelin/contracts/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/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// @openzeppelin/contracts/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/token/ERC20/IERC20.sol
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
interface IOdosExecutor {
function executePath (bytes calldata bytecode,
uint256[] memory inputAmount) external payable;
}
interface IDaiStylePermit {
function permit(address holder,
address spender,
uint256 nonce,
uint256 expiry,
bool allowed,
uint8 v,
bytes32 r,
bytes32 s) external;
}
/// @title Routing contract for Odos SOR
/// @author Semiotic AI
/// @notice Wrapper with security gaurentees around execution of arbitrary operations on user tokens
contract OdosRouter is Ownable {
using SafeERC20 for IERC20;
/// @dev The zero address is uniquely used to represent eth since it is already
/// recognized as an invalid ERC20, and due to its gas efficiency
address constant _ETH = address(0);
/// @dev Contains all information needed to describe an input token being swapped from
struct inputToken {
address tokenAddress;
uint256 amountIn;
address receiver;
bytes permit;
}
/// @dev Contains all information needed to describe an output token being swapped to
struct outputToken {
address tokenAddress;
uint256 relativeValue;
address receiver;
}
/// @dev Swap event logging
event Swapped(address sender,
uint256[] amountsIn,
address[] tokensIn,
uint256[] amountsOut,
outputToken[] outputs,
uint256 valueOutQuote);
/// @dev Must exist in order for contract to receive eth
receive() external payable { }
/// @notice Performs a swap for a given value of some combination of specified output tokens
/// @param inputs list of input token structs for the path being executed
/// @param outputs list of output token structs for the path being executed
/// @param valueOutQuote value of destination tokens quoted for the path
/// @param valueOutMin minimum amount of value out the user will accept
/// @param executor Address of contract that will execute the path
/// @param pathDefinition Encoded path definition for executor
function swap(inputToken[] memory inputs,
outputToken[] memory outputs,
uint256 valueOutQuote,
uint256 valueOutMin,
address executor,
bytes calldata pathDefinition)
external
payable
returns (uint256[] memory amountsOut, uint256 gasLeft)
{
// Check for valid output specifications
require(valueOutMin <= valueOutQuote, "Minimum greater than quote");
require(valueOutMin > 0, "Slippage limit too low");
// Check input specification validity and transfer input tokens to executor
{
uint256 expected_msg_value = 0;
for (uint256 i = 0; i < inputs.length; i++) {
for (uint256 j = 0; j < i; j++) {
require(inputs[i].tokenAddress != inputs[j].tokenAddress,
"Duplicate source tokens");
}
for (uint256 j = 0; j < outputs.length; j++) {
require(inputs[i].tokenAddress != outputs[j].tokenAddress,
"Arbitrage not supported");
}
if (inputs[i].tokenAddress == _ETH) {
expected_msg_value = inputs[i].amountIn;
}
else {
_permit(inputs[i].tokenAddress, inputs[i].permit);
IERC20(inputs[i].tokenAddress).safeTransferFrom(msg.sender,
inputs[i].receiver,
inputs[i].amountIn);
}
}
require(msg.value == expected_msg_value, "Invalid msg.value");
}
// Check outputs for duplicates and record balances before swap
uint256[] memory balancesBefore = new uint256[](outputs.length);
for (uint256 i = 0; i < outputs.length; i++) {
for (uint256 j = 0; j < i; j++) {
require(outputs[i].tokenAddress != outputs[j].tokenAddress,
"Duplicate destination tokens");
}
balancesBefore[i] = _universalBalance(outputs[i].tokenAddress);
}
// Extract arrays of input amount values and tokens from the inputs struct list
uint256[] memory amountsIn = new uint256[](inputs.length);
address[] memory tokensIn = new address[](inputs.length);
{
for (uint256 i = 0; i < inputs.length; i++) {
amountsIn[i] = inputs[i].amountIn;
tokensIn[i] = inputs[i].tokenAddress;
}
}
// Delegate the execution of the path to the specified Odos Executor
IOdosExecutor(executor).executePath{value: msg.value}(pathDefinition, amountsIn);
{
uint256 valueOut;
amountsOut = new uint256[](outputs.length);
for (uint256 i = 0; i < outputs.length; i++) {
if (valueOut == valueOutQuote) break;
// Record the destination token balance before the path is executed
amountsOut[i] = _universalBalance(outputs[i].tokenAddress) - balancesBefore[i];
valueOut += amountsOut[i] * outputs[i].relativeValue;
// If the value out excedes the quoted value out, transfer enough to
// fulfil the quote and break the loop (any other tokens will be over quote)
if (valueOut > valueOutQuote) {
amountsOut[i] -= (valueOut - valueOutQuote) / outputs[i].relativeValue;
valueOut = valueOutQuote;
}
_universalTransfer(outputs[i].tokenAddress,
outputs[i].receiver,
amountsOut[i]);
}
require(valueOut > valueOutMin, "Slippage Limit Exceeded");
}
emit Swapped(msg.sender,
amountsIn,
tokensIn,
amountsOut,
outputs,
valueOutQuote);
gasLeft = gasleft();
}
/// @notice Allows the owner to transfer funds held by the router contract
/// @param tokens List of token address to be transferred
/// @param amounts List of amounts of each token to be transferred
/// @param dest Address to which the funds should be sent
function transferFunds(address[] calldata tokens,
uint256[] calldata amounts,
address dest)
external
onlyOwner
{
require(tokens.length == amounts.length, "Invalid funds transfer");
for (uint256 i = 0; i < tokens.length; i++) {
_universalTransfer(tokens[i], dest, amounts[i]);
}
}
/// @notice helper function to get balance of ERC20 or native coin for this contract
/// @param token address of the token to check, null for native coin
/// @return balance of specified coin or token
function _universalBalance(address token) private view returns(uint256) {
if (token == _ETH) {
return address(this).balance;
} else {
return IERC20(token).balanceOf(address(this));
}
}
/// @notice helper function to transfer ERC20 or native coin
/// @param token address of the token being transferred, null for native coin
/// @param to address to transfer to
/// @param amount to transfer
function _universalTransfer(address token, address to, uint256 amount) private {
if (token == _ETH) {
(bool success,) = payable(to).call{value: amount}("");
require(success, "ETH transfer failed");
} else {
IERC20(token).safeTransfer(to, amount);
}
}
/// @notice Executes an ERC20 or Dai Style Permit
/// @param token address of token permit is for
/// @param permit the byte information for permit execution, 0 for no operation
function _permit(address token, bytes memory permit) internal {
if (permit.length > 0) {
if (permit.length == 32 * 7) {
(bool success,) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit));
require(success, "IERC20Permit failed");
} else if (permit.length == 32 * 8) {
(bool success,) = token.call(abi.encodePacked(IDaiStylePermit.permit.selector, permit));
require(success, "Dai Style Permit failed");
} else {
revert("Invalid Permit");
}
}
}
}
| 152,888 | 13,892 |
148798c282f0c529383a397bd3f39036194073c363e99839ee4260a35c26f0b0
| 27,229 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/48/48D05d332C249393AbD9D1F7d5afE04e4F7067ac_StrudelStaking.sol
| 4,138 | 16,540 |
// 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 IsORKAN {
function rebase(uint256 orkanProfit_, 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 StrudelStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public ORKAN;
address public sORKAN;
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 _ORKAN,
address _sORKAN,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_ORKAN != address(0));
ORKAN = _ORKAN;
require(_sORKAN != address(0));
sORKAN = _sORKAN;
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(ORKAN).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(IsORKAN(sORKAN).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sORKAN).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, IsORKAN(sORKAN).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsORKAN(sORKAN).balanceForGons(info.gons));
IERC20(ORKAN).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(sORKAN).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(ORKAN).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsORKAN(sORKAN).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsORKAN(sORKAN).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 = IsORKAN(sORKAN).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(ORKAN).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sORKAN).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sORKAN).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;
}
}
| 325,625 | 13,893 |
fdfcea343bc5ca1810fb12976b55eb0f6b3f709070f9b0d11b6d597de47349a0
| 17,996 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x521ed218348577fa2915b9454b72712024d350d2.sol
| 2,758 | 10,501 |
pragma solidity ^0.4.18;
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);
}
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 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 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 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[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_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];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract MintableToken is StandardToken, Ownable {
uint public totalSupply = 0;
address minter;
modifier onlyMinter(){
require(minter == msg.sender);
_;
}
function setMinter(address _minter) onlyOwner {
minter = _minter;
}
function mint(address _to, uint _amount) onlyMinter {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(address(0x0), _to, _amount);
}
}
contract ERC23 is ERC20Basic {
function transfer(address to, uint value, bytes data);
event TransferData(address indexed from, address indexed to, uint value, bytes data);
}
contract ERC23PayableReceiver {
function tokenFallback(address _from, uint _value, bytes _data) payable;
}
contract ERC23PayableToken is BasicToken, ERC23{
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address to, uint value, bytes data){
transferAndPay(to, value, data);
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address to, uint value) returns (bool){
bytes memory empty;
transfer(to, value, empty);
return true;
}
function transferAndPay(address to, uint value, bytes data) payable {
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly .
codeLength := extcodesize(to)
}
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
if(codeLength>0) {
ERC23PayableReceiver receiver = ERC23PayableReceiver(to);
receiver.tokenFallback.value(msg.value)(msg.sender, value, data);
}else if(msg.value > 0){
to.transfer(msg.value);
}
Transfer(msg.sender, to, value);
if(data.length > 0)
TransferData(msg.sender, to, value, data);
}
}
contract NYXToken is MintableToken, ERC23PayableToken {
string public constant name = "NYX Token";
string public constant symbol = "NYX";
uint constant decimals = 0;
bool public transferEnabled = true;
//The cap is 15 mln NYX
uint private constant CAP = 15*(10**6);
function mint(address _to, uint _amount){
require(totalSupply.add(_amount) <= CAP);
super.mint(_to, _amount);
}
function NYXToken(address team) {
//Transfer ownership on the token to team on creation
transferOwnership(team);
// minter is the TokenSale contract
minter = msg.sender;
/// Preserve 3 000 000 tokens for the team
mint(team, 3000000);
}
function transferAndPay(address to, uint value, bytes data) payable{
require(transferEnabled);
super.transferAndPay(to, value, data);
}
function enableTransfer(bool enabled) onlyOwner{
transferEnabled = enabled;
}
}
contract TokenSale is Ownable {
using SafeMath for uint;
// Constants
// =========
uint private constant millions = 1e6;
uint private constant CAP = 15*millions;
uint private constant SALE_CAP = 12*millions;
uint private constant SOFT_CAP = 1400000;
// Allocated for the team upon contract creation
// =========
uint private constant TEAM_CAP = 3000000;
uint public price = 0.001 ether;
// Hold investor's ether amounts to refund
address[] contributors;
mapping(address => uint) contributions;
// Events
// ======
event AltBuy(address holder, uint tokens, string txHash);
event Buy(address holder, uint tokens);
event RunSale();
event PauseSale();
event FinishSale();
event PriceSet(uint weiPerNYX);
// State variables
// ===============
bool public presale;
NYXToken public token;
address authority; //An account to control the contract on behalf of the owner
address robot; //An account to purchase tokens for altcoins
bool public isOpen = true;
// Constructor
// ===========
function TokenSale(){
token = new NYXToken(msg.sender);
authority = msg.sender;
robot = msg.sender;
transferOwnership(msg.sender);
}
// Public functions
// ================
function togglePresale(bool activate) onlyOwner {
presale = activate;
}
function getCurrentPrice() constant returns(uint) {
if(presale) {
return price - (price*20/100);
}
return price;
}
function getTokensAmount(uint etherVal) constant returns (uint) {
uint tokens = 0;
tokens += etherVal/getCurrentPrice();
return tokens;
}
function buy(address to) onlyOpen payable{
uint amount = msg.value;
uint tokens = getTokensAmountUnderCap(amount);
// owner.transfer(amount);
token.mint(to, tokens);
uint alreadyContributed = contributions[to];
if(alreadyContributed == 0) // new contributor
contributors.push(to);
contributions[to] = contributions[to].add(msg.value);
Buy(to, tokens);
}
function () payable{
buy(msg.sender);
}
// Modifiers
// =================
modifier onlyAuthority() {
require(msg.sender == authority || msg.sender == owner);
_;
}
modifier onlyRobot() {
require(msg.sender == robot);
_;
}
modifier onlyOpen() {
require(isOpen);
_;
}
// Priveleged functions
// ====================
function buyAlt(address to, uint etherAmount, string _txHash) onlyRobot {
uint tokens = getTokensAmountUnderCap(etherAmount);
token.mint(to, tokens);
AltBuy(to, tokens, _txHash);
}
function setAuthority(address _authority) onlyOwner {
authority = _authority;
}
function setRobot(address _robot) onlyAuthority {
robot = _robot;
}
function setPrice(uint etherPerNYX) onlyAuthority {
price = etherPerNYX;
PriceSet(price);
}
// SALE state management: start / pause / finalize
// --------------------------------------------
function open(bool opn) onlyAuthority {
isOpen = opn;
opn ? RunSale() : PauseSale();
}
function finalize() onlyAuthority {
// Check for SOFT_CAP
if(token.totalSupply() < SOFT_CAP + TEAM_CAP) { // Soft cap is not reached, return all contributions to investors
uint x = 0;
while(x < contributors.length) {
uint amountToReturn = contributions[contributors[x]];
contributors[x].transfer(amountToReturn);
x++;
}
}
uint diff = CAP.sub(token.totalSupply());
if(diff > 0) //The unsold capacity moves to team
token.mint(owner, diff);
selfdestruct(owner);
FinishSale();
}
// Private functions
// =========================
function getTokensAmountUnderCap(uint etherAmount) private constant returns (uint){
uint tokens = getTokensAmount(etherAmount);
require(tokens > 0);
require(tokens.add(token.totalSupply()) <= SALE_CAP);
return tokens;
}
}
| 206,071 | 13,894 |
4fbd3dc73e1c5838a94536b731facd0b1b83397780ad0b1290ded1875f8ae807
| 20,116 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/9d/9d2189a0ebe41256c8ed25aef496682faa8687e2_Oracle.sol
| 2,887 | 10,925 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;
abstract contract LinkTokenReceiver {
bytes4 constant private ORACLE_REQUEST_SELECTOR = 0x40429946;
uint256 constant private SELECTOR_LENGTH = 4;
uint256 constant private EXPECTED_REQUEST_WORDS = 2;
uint256 constant private MINIMUM_REQUEST_LENGTH = SELECTOR_LENGTH + (32 * EXPECTED_REQUEST_WORDS);
function onTokenTransfer(address _sender,
uint256 _amount,
bytes memory _data)
public
onlyLINK
validRequestLength(_data)
permittedFunctionsForLINK(_data)
{
assembly {
// solhint-disable-next-line avoid-low-level-calls
mstore(add(_data, 36), _sender) // ensure correct sender is passed
// solhint-disable-next-line avoid-low-level-calls
mstore(add(_data, 68), _amount) // ensure correct amount is passed
}
// solhint-disable-next-line avoid-low-level-calls
(bool success,) = address(this).delegatecall(_data); // calls oracleRequest
require(success, "Unable to create request");
}
function getChainlinkToken() public view virtual returns (address);
modifier onlyLINK() {
require(msg.sender == getChainlinkToken(), "Must use LINK token");
_;
}
modifier permittedFunctionsForLINK(bytes memory _data) {
bytes4 funcSelector;
assembly {
// solhint-disable-next-line avoid-low-level-calls
funcSelector := mload(add(_data, 32))
}
require(funcSelector == ORACLE_REQUEST_SELECTOR, "Must use whitelisted functions");
_;
}
modifier validRequestLength(bytes memory _data) {
require(_data.length >= MINIMUM_REQUEST_LENGTH, "Invalid request length");
_;
}
}
interface ChainlinkRequestInterface {
function oracleRequest(address sender,
uint256 requestPrice,
bytes32 serviceAgreementID,
address callbackAddress,
bytes4 callbackFunctionId,
uint256 nonce,
uint256 dataVersion,
bytes calldata data) external;
function cancelOracleRequest(bytes32 requestId,
uint256 payment,
bytes4 callbackFunctionId,
uint256 expiration) external;
}
interface OracleInterface {
function fulfillOracleRequest(bytes32 requestId,
uint256 payment,
address callbackAddress,
bytes4 callbackFunctionId,
uint256 expiration,
bytes32 data) external returns (bool);
function getAuthorizationStatus(address node) external view returns (bool);
function setFulfillmentPermission(address node, bool allowed) external;
function withdraw(address recipient, uint256 amount) external;
function withdrawable() external view returns (uint256);
}
interface LinkTokenInterface {
function allowance(address owner, address spender) external view returns (uint256 remaining);
function approve(address spender, uint256 value) external returns (bool success);
function balanceOf(address owner) external view returns (uint256 balance);
function decimals() external view returns (uint8 decimalPlaces);
function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
function increaseApproval(address spender, uint256 subtractedValue) external;
function name() external view returns (string memory tokenName);
function symbol() external view returns (string memory tokenSymbol);
function totalSupply() external view returns (uint256 totalTokensIssued);
function transfer(address to, uint256 value) external returns (bool success);
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
}
interface WithdrawalInterface {
function withdraw(address recipient, uint256 amount) external;
function withdrawable() external view returns (uint256);
}
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(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
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;
}
}
library SafeMathChainlink {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract Oracle is ChainlinkRequestInterface, OracleInterface, Ownable, LinkTokenReceiver, WithdrawalInterface {
using SafeMathChainlink for uint256;
uint256 constant public EXPIRY_TIME = 5 minutes;
uint256 constant private MINIMUM_CONSUMER_GAS_LIMIT = 400000;
// We initialize fields to 1 instead of 0 so that the first invocation
// does not cost more gas.
uint256 constant private ONE_FOR_CONSISTENT_GAS_COST = 1;
LinkTokenInterface internal LinkToken;
mapping(bytes32 => bytes32) private commitments;
mapping(address => bool) private authorizedNodes;
uint256 private withdrawableTokens = ONE_FOR_CONSISTENT_GAS_COST;
event OracleRequest(bytes32 indexed specId,
address requester,
bytes32 requestId,
uint256 payment,
address callbackAddr,
bytes4 callbackFunctionId,
uint256 cancelExpiration,
uint256 dataVersion,
bytes data);
event CancelOracleRequest(bytes32 indexed requestId);
constructor(address _link)
public
Ownable()
{
LinkToken = LinkTokenInterface(_link); // external but already deployed and unalterable
}
function oracleRequest(address _sender,
uint256 _payment,
bytes32 _specId,
address _callbackAddress,
bytes4 _callbackFunctionId,
uint256 _nonce,
uint256 _dataVersion,
bytes calldata _data)
external
override
onlyLINK()
checkCallbackAddress(_callbackAddress)
{
bytes32 requestId = keccak256(abi.encodePacked(_sender, _nonce));
require(commitments[requestId] == 0, "Must use a unique ID");
// solhint-disable-next-line not-rely-on-time
uint256 expiration = now.add(EXPIRY_TIME);
commitments[requestId] = keccak256(abi.encodePacked(_payment,
_callbackAddress,
_callbackFunctionId,
expiration));
emit OracleRequest(_specId,
_sender,
requestId,
_payment,
_callbackAddress,
_callbackFunctionId,
expiration,
_dataVersion,
_data);
}
function fulfillOracleRequest(bytes32 _requestId,
uint256 _payment,
address _callbackAddress,
bytes4 _callbackFunctionId,
uint256 _expiration,
bytes32 _data)
external
onlyAuthorizedNode
override
isValidRequest(_requestId)
returns (bool)
{
bytes32 paramsHash = keccak256(abi.encodePacked(_payment,
_callbackAddress,
_callbackFunctionId,
_expiration));
require(commitments[_requestId] == paramsHash, "Params do not match request ID");
withdrawableTokens = withdrawableTokens.add(_payment);
delete commitments[_requestId];
require(gasleft() >= MINIMUM_CONSUMER_GAS_LIMIT, "Must provide consumer enough gas");
// All updates to the oracle's fulfillment should come before calling the
// callback(addr+functionId) as it is untrusted.
(bool success,) = _callbackAddress.call(abi.encodeWithSelector(_callbackFunctionId, _requestId, _data)); // solhint-disable-line avoid-low-level-calls
return success;
}
function getAuthorizationStatus(address _node)
external
view
override
returns (bool)
{
return authorizedNodes[_node];
}
function setFulfillmentPermission(address _node, bool _allowed)
external
override
onlyOwner()
{
authorizedNodes[_node] = _allowed;
}
function withdraw(address _recipient, uint256 _amount)
external
override(OracleInterface, WithdrawalInterface)
onlyOwner
hasAvailableFunds(_amount)
{
withdrawableTokens = withdrawableTokens.sub(_amount);
assert(LinkToken.transfer(_recipient, _amount));
}
function withdrawable()
external
view
override(OracleInterface, WithdrawalInterface)
onlyOwner()
returns (uint256)
{
return withdrawableTokens.sub(ONE_FOR_CONSISTENT_GAS_COST);
}
function cancelOracleRequest(bytes32 _requestId,
uint256 _payment,
bytes4 _callbackFunc,
uint256 _expiration)
external
override
{
bytes32 paramsHash = keccak256(abi.encodePacked(_payment,
msg.sender,
_callbackFunc,
_expiration));
require(paramsHash == commitments[_requestId], "Params do not match request ID");
// solhint-disable-next-line not-rely-on-time
require(_expiration <= now, "Request is not expired");
delete commitments[_requestId];
emit CancelOracleRequest(_requestId);
assert(LinkToken.transfer(msg.sender, _payment));
}
function getChainlinkToken()
public
view
override
returns (address)
{
return address(LinkToken);
}
// MODIFIERS
modifier hasAvailableFunds(uint256 _amount) {
require(withdrawableTokens >= _amount.add(ONE_FOR_CONSISTENT_GAS_COST), "Amount requested is greater than withdrawable balance");
_;
}
modifier isValidRequest(bytes32 _requestId) {
require(commitments[_requestId] != 0, "Must have a valid requestId");
_;
}
modifier onlyAuthorizedNode() {
require(authorizedNodes[msg.sender] || msg.sender == owner(), "Not an authorized node to fulfill requests");
_;
}
modifier checkCallbackAddress(address _to) {
require(_to != address(LinkToken), "Cannot callback to LINK");
_;
}
}
| 104,373 | 13,895 |
bd43cb9aba01b4eb5452d0b91ad255f9da304cbc37db401944571050ab69405d
| 13,783 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/be/BE77BfBF33eEc311581F5C40923815cF3f16924E_xHEALTH.sol
| 3,441 | 13,251 |
pragma solidity ^0.8.6;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {return msg.sender;}
function _msgData() internal view virtual returns (bytes calldata) {this; return msg.data;}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size; assembly { size := extcodesize(account) } return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) { return returndata; } else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {revert(errorMessage);}
}
}
}
abstract contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
}
contract xHEALTH is IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
string constant _name = "xHEALTH";
string constant _symbol = "xHEALTH";
uint8 constant _decimals = 18;
uint256 internal _totalSupply = 200000 * (10**18);
bool public isPresale = true;
bool public isInSale = true;
uint256 public pricePerToken = 10;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isInWhitelist;
address private teamWallet = 0x42e8d918fcDCCBeFc860dE058e6D7E60eF4fb6bA;
IERC20 _USDC = IERC20(0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E);
constructor(address _usdc) {
_balances[msg.sender] = _totalSupply;
_USDC = IERC20(_usdc);
_approve(owner(), address(this), ~uint256(0));
emit Transfer(address(0), msg.sender, _totalSupply);
}
function setTokenPrice(uint256 _price) public onlyOwner {
pricePerToken = _price;
}
function includeInWhitelist(address _addr) public onlyOwner {
isInWhitelist[_addr] = true;
}
function excludedFromWhitelist(address _addr) public onlyOwner {
isInWhitelist[_addr] = false;
}
function tooglePresale(bool state) public onlyOwner {
isPresale = state;
}
function toogleSale(bool state) public onlyOwner {
isInSale = state;
}
function decimals() external pure returns (uint8) {
return _decimals;
}
function symbol() external pure returns (string memory) {
return _symbol;
}
function name() external pure returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "xHEALTH: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "xHEALTH: decreased allowance below zero"));
return true;
}
function buyToken(address buyer, uint256 amount) public {
require(isInSale == true, "xHEALTH: sale finished.");
require(_USDC.transferFrom(buyer, teamWallet, pricePerToken * amount) == true, "xHEALTH: usdc transfer failed.");
require(amount <= _balances[owner()], "xHEALTH: insufficient balance in owner.");
if(isPresale == true) {
require(isInWhitelist[buyer] == true, "xHEALTH: you can't buy token now.");
}
_transfer(owner(), buyer, amount);
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "xHEALTH: transfer from the zero address");
require(recipient != address(0), "xHEALTH: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "xHEALTH: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "xHEALTH: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "xHEALTH: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "xHEALTH: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "xHEALTH: approve from the zero address");
require(spender != address(0), "xHEALTH: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "xHEALTH: burn amount exceeds allowance"));
}
}
| 130,294 | 13,896 |
62ce61c12e734f106782be4eaf426aacaf2386373eb13215df387620b880bfa0
| 25,858 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/33/3372BC41f7A267907fBFB04C5DC3e4511141B8be_Staking.sol
| 4,414 | 17,577 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
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 LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IBang is IERC20 {
function rebase(uint256 ohmProfit_, uint256 epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override 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 Staking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IBang;
IERC20 public immutable Big;
IBang public immutable Bang;
struct Epoch {
uint256 number;
uint256 distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint256 public totalBonus;
IWarmup public warmupContract;
uint256 public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint256 period);
constructor (address _Big,
address _Bang,
uint32 _epochLength,
uint256 _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Big != address(0));
require(_Bang != address(0));
Bang = IBang(_Bang);
Big = IERC20(_Big);
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
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();
Big.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(Bang.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
Bang.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim(address _recipient) external {
Claim memory info = warmupInfo[_recipient];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[_recipient];
uint256 amount = Bang.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
uint256 memoBalance = Bang.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Big.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint256 _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
Bang.safeTransferFrom(msg.sender, address(this), _amount);
Big.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint256) {
return Bang.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
Bang.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint256 balance = contractBalance();
uint256 staked = Bang.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint256) {
return Big.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS {DISTRIBUTOR, WARMUP}
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint256 _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 75,588 | 13,897 |
e20c720292781eee6796dda166e94b8076b1cfb77fd8dc4c5d0882b81d9a1ab0
| 19,423 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUjKCSsuTXmKQPFEC1M4UK8hRvi9kSKKb7_Router.sol
| 5,641 | 19,206 |
//SourceUnit: Router.sol
pragma solidity 0.5.12;
interface ITRC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function approve(address spender, uint256 value) external returns(bool);
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function name() external view returns(string memory);
function symbol() external view returns(string memory);
function decimals() external view returns(uint8);
function totalSupply() external view returns(uint256);
function balanceOf(address owner) external view returns(uint256);
function allowance(address owner, address spender) external view returns(uint256);
}
interface IFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256 index);
function createPair(address tokenA, address tokenB) external returns(address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function feeTo() external view returns(address);
function feeToSetter() external view returns(address);
function getPair(address tokenA, address tokenB) external view returns(address pair);
function allPairs(uint256) external view returns(address pair);
function allPairsLength() external view returns(uint256);
}
interface IPair {
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function mint(address to) external returns(uint256 liquidity);
function burn(address to) external returns(uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
function MINIMUM_LIQUIDITY() external pure returns(uint256);
function factory() external view returns(address);
function token0() external view returns(address);
function token1() external view returns(address);
function getReserves() external view returns(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns(uint256);
function price1CumulativeLast() external view returns(uint256);
function kLast() external view returns(uint256);
}
interface IWTRX {
function deposit() external payable;
function withdraw(uint256) external;
}
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint256 x, uint256 y) internal pure returns(uint256 z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library TransferHelper {
function safeTransfer(address token, address to, uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (token == 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C || data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferTRX(address to, uint256 value) internal {
(bool success,) = to.call.value(value)(new bytes(0));
require(success, 'TransferHelper: TRX_TRANSFER_FAILED');
}
}
library SwapLibrary {
using SafeMath for uint256;
function sortTokens(address tokenA, address tokenB) internal pure returns(address token0, address token1) {
require(tokenA != tokenB, 'SwapLibrary: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'SwapLibrary: ZERO_ADDRESS');
}
function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) internal pure returns(uint256 amountB) {
require(amountA > 0, 'SwapLibrary: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) internal pure returns(uint256 amountOut) {
require(amountIn > 0, 'SwapLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
uint256 amountInWithFee = amountIn.mul(997);
amountOut = amountInWithFee.mul(reserveOut) / reserveIn.mul(1000).add(amountInWithFee);
}
function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) internal pure returns(uint256 amountIn) {
require(amountOut > 0, 'SwapLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
amountIn = (reserveIn.mul(amountOut).mul(1000) / reserveOut.sub(amountOut).mul(997)).add(1);
}
function pairFor(address factory, address tokenA, address tokenB) internal view returns(address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = IFactory(factory).getPair(token0, token1);
require(pair != address(0), "SwapLibrary: UNDEFINED_PAIR");
}
function getReserves(address factory, address tokenA, address tokenB) internal view returns(uint256 reserveA, uint256 reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint256 reserve0, uint256 reserve1,) = IPair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
function getAmountsOut(address factory, uint256 amountIn, address[] memory path) internal view returns(uint256[] memory amounts) {
require(path.length >= 2, 'SwapLibrary: INVALID_PATH');
amounts = new uint256[](path.length);
amounts[0] = amountIn;
for(uint256 i; i < path.length - 1; i++) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
function getAmountsIn(address factory, uint256 amountOut, address[] memory path) internal view returns(uint256[] memory amounts) {
require(path.length >= 2, 'SwapLibrary: INVALID_PATH');
amounts = new uint256[](path.length);
amounts[amounts.length - 1] = amountOut;
for(uint256 i = path.length - 1; i > 0; i--) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
contract Router {
using SafeMath for uint256;
address public factory;
address public wtrx;
address[] public pairvalue;
uint public amtvalue;
bool public ccc;
bool public ccc1;
modifier ensure(uint256 deadline) {
require(deadline >= block.timestamp, 'Router: EXPIRED');
_;
}
constructor(address _factory, address _wtrx) public {
factory = _factory;
wtrx = _wtrx;
}
function() payable external {
assert(msg.sender == wtrx);
}
function _addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin) internal returns(uint256 amountA, uint256 amountB) {
if(IFactory(factory).getPair(tokenA, tokenB) == address(0)) {
IFactory(factory).createPair(tokenA, tokenB);
}
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
if(reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
}
else {
uint256 amountBOptimal = SwapLibrary.quote(amountADesired, reserveA, reserveB);
if(amountBOptimal <= amountBDesired) {
require(amountBOptimal >= amountBMin, 'Router: INSUFFICIENT_B_AMOUNT');
(amountA, amountB) = (amountADesired, amountBOptimal);
}
else {
uint256 amountAOptimal = SwapLibrary.quote(amountBDesired, reserveB, reserveA);
assert(amountAOptimal <= amountADesired);
require(amountAOptimal >= amountAMin, 'Router: INSUFFICIENT_A_AMOUNT');
(amountA, amountB) = (amountAOptimal, amountBDesired);
}
}
}
function _swap(uint256[] memory amounts, address[] memory path, address _to) internal {
for(uint256 i; i < path.length - 1; i++) {
(address input, address output) = (path[i], path[i + 1]);
(address token0,) = SwapLibrary.sortTokens(input, output);
uint256 amountOut = amounts[i + 1];
(uint256 amount0Out, uint256 amount1Out) = input == token0 ? (uint256(0), amountOut) : (amountOut, uint256(0));
address to = i < path.length - 2 ? SwapLibrary.pairFor(factory, output, path[i + 2]) : _to;
IPair(SwapLibrary.pairFor(factory, input, output)).swap(amount0Out, amount1Out, to, new bytes(0));
}
}
function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external ensure(deadline) returns(uint256 amountA, uint256 amountB, uint256 liquidity) {
(amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
address pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
liquidity = IPair(pair).mint(to);
}
function addLiquidityTRX(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountTRXMin, address to, uint256 deadline) external payable ensure(deadline) returns(uint256 amountToken, uint256 amountTRX, uint256 liquidity) {
(amountToken, amountTRX) = _addLiquidity(token, wtrx, amountTokenDesired, msg.value, amountTokenMin, amountTRXMin);
address pair = SwapLibrary.pairFor(factory, token, wtrx);
TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
IWTRX(wtrx).deposit.value(amountTRX)();
assert(ITRC20(wtrx).transfer(pair, amountTRX));
liquidity = IPair(pair).mint(to);
if(msg.value > amountTRX) TransferHelper.safeTransferTRX(msg.sender, msg.value - amountTRX);
}
function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) public ensure(deadline) returns(uint256 amountA, uint256 amountB) {
address pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
ITRC20(pair).transferFrom(msg.sender, pair, liquidity);
(uint256 amount0, uint256 amount1) = IPair(pair).burn(to);
(address token0,) = SwapLibrary.sortTokens(tokenA, tokenB);
(amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
require(amountA >= amountAMin, 'Router: INSUFFICIENT_A_AMOUNT');
require(amountB >= amountBMin, 'Router: INSUFFICIENT_B_AMOUNT');
}
function removeLiquidityTRX(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountTRXMin, address to, uint256 deadline) public ensure(deadline) returns(uint256 amountToken, uint256 amountTRX) {
(amountToken, amountTRX) = removeLiquidity(token, wtrx, liquidity, amountTokenMin, amountTRXMin, address(this), deadline);
TransferHelper.safeTransfer(token, to, amountToken);
IWTRX(wtrx).withdraw(amountTRX);
TransferHelper.safeTransferTRX(to, amountTRX);
}
function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
amounts = SwapLibrary.getAmountsOut(factory, amountIn, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, to);
}
function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= amountInMax, 'Router: EXCESSIVE_INPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, to);
}
function swapExactTRXForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external payable ensure(deadline) returns(uint256[] memory amounts) {
require(path[0] == wtrx, 'Router: INVALID_PATH');
pairvalue = path;
amounts = SwapLibrary.getAmountsOut(factory, msg.value, path);
amtvalue=amounts[0];
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
IWTRX(wtrx).deposit.value(amounts[0])();
ccc=true;
assert(ITRC20(wtrx).transfer(SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]));
ccc1=true;
_swap(amounts, path, to);
}
function swapTRXForExactTokens(uint256 amountOut, address[] calldata path, address to, uint256 deadline) external payable ensure(deadline) returns(uint256[] memory amounts) {
require(path[0] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= msg.value, 'Router: EXCESSIVE_INPUT_AMOUNT');
IWTRX(wtrx).deposit.value(amounts[0])();
assert(ITRC20(wtrx).transfer(SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]));
_swap(amounts, path, to);
if(msg.value > amounts[0]) TransferHelper.safeTransferTRX(msg.sender, msg.value - amounts[0]);
}
function swapExactTokensForTRX(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
require(path[path.length - 1] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsOut(factory, amountIn, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, address(this));
IWTRX(wtrx).withdraw(amounts[amounts.length - 1]);
TransferHelper.safeTransferTRX(to, amounts[amounts.length - 1]);
}
function swapTokensForExactTRX(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
require(path[path.length - 1] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= amountInMax, 'Router: EXCESSIVE_INPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, address(this));
IWTRX(wtrx).withdraw(amounts[amounts.length - 1]);
TransferHelper.safeTransferTRX(to, amounts[amounts.length - 1]);
}
function getAmountsIn(uint256 amountOut, address[] memory path) public view returns (uint256[] memory amounts) {
return SwapLibrary.getAmountsIn(factory, amountOut, path);
}
function getAmountsOut(uint256 amountIn, address[] memory path) public view returns(uint256[] memory amounts) {
return SwapLibrary.getAmountsOut(factory, amountIn, path);
}
function calcPairLiquidity(uint256 amountA, address tokenA, address tokenB, bool reverse) external view returns(uint256 amountB, uint256 share) {
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
amountB = reverse ? SwapLibrary.quote(amountA, reserveB, reserveA) : SwapLibrary.quote(amountA, reserveA, reserveB);
share = reverse ? amountA.mul(100) / reserveB.add(amountA) : amountA.mul(100) / reserveA.add(amountA);
}
function calcPairSwap(uint256 amountA, address tokenA, address tokenB, bool reverse) external view returns(uint256 amountB, uint256 priceImpact) {
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
amountB = reverse ? SwapLibrary.getAmountIn(amountA, reserveA, reserveB) : SwapLibrary.getAmountOut(amountA, reserveA, reserveB);
priceImpact = reverse ? reserveA.sub(reserveA.sub(amountB)).mul(10000) / reserveA : reserveB.sub(reserveB.sub(amountB)).mul(10000) / reserveB;
}
function getPair(address owner, address tokenA, address tokenB) external view returns(address pair, uint256 totalSupply, uint256 supply, uint256 reserveA, uint256 reserveB) {
pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
totalSupply = ITRC20(pair).totalSupply();
supply = ITRC20(pair).balanceOf(owner);
(address token0,) = SwapLibrary.sortTokens(tokenA, tokenB);
if(token0 != tokenA) (reserveB, reserveA) = SwapLibrary.getReserves(factory, tokenA, tokenB);
else (reserveA, reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
}
function getPairs(address owner, uint256 start, uint256 limit) external view returns(uint256 count, address[] memory from, address[] memory to, uint256[] memory supply) {
count = IFactory(factory).allPairsLength();
from = new address[](limit);
to = new address[](limit);
supply = new uint256[](limit);
uint256 matches = 0;
for(uint256 i = start; i < start + limit && i < count; i++) {
address pair = IFactory(factory).allPairs(i);
from[matches] = IPair(pair).token0();
to[matches] = IPair(pair).token1();
supply[matches++] = ITRC20(pair).balanceOf(owner);
}
}
}
| 303,528 | 13,898 |
9ad1d6027c533986b6afe23b4e699d90f36c4b119e391f6985e7eacbf40bc5f8
| 13,167 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc20f72996879161e45e39e0a93297905959589a2.sol
| 3,231 | 12,549 |
pragma solidity ^0.4.16;
// copyright contact@Etheremon.com
contract SafeMath {
function safeAdd(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) pure internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
}
contract BasicAccessControl {
address public owner;
// address[] public moderators;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract EtheremonEnum {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_TRAINER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum ArrayType {
CLASS_TYPE,
STAT_STEP,
STAT_START,
STAT_BASE,
OBJ_SKILL
}
enum PropertyType {
ANCESTOR,
XFACTOR
}
}
contract EtheremonDataBase is EtheremonEnum, BasicAccessControl, SafeMath {
uint64 public totalMonster;
uint32 public totalClass;
// write
function withdrawEther(address _sendTo, uint _amount) onlyOwner public returns(ResultCode);
function addElementToArrayType(ArrayType _type, uint64 _id, uint8 _value) onlyModerators public returns(uint);
function updateIndexOfArrayType(ArrayType _type, uint64 _id, uint _index, uint8 _value) onlyModerators public returns(uint);
function setMonsterClass(uint32 _classId, uint256 _price, uint256 _returnPrice, bool _catchable) onlyModerators public returns(uint32);
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64);
function setMonsterObj(uint64 _objId, string _name, uint32 _exp, uint32 _createIndex, uint32 _lastClaimIndex) onlyModerators public;
function increaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function decreaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function removeMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function addMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function clearMonsterReturnBalance(uint64 _monsterId) onlyModerators public returns(uint256 amount);
function collectAllReturnBalance(address _trainer) onlyModerators public returns(uint256 amount);
function transferMonster(address _from, address _to, uint64 _monsterId) onlyModerators public returns(ResultCode);
function addExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function deductExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function setExtraBalance(address _trainer, uint256 _amount) onlyModerators public;
// read
function getSizeArrayType(ArrayType _type, uint64 _id) constant public returns(uint);
function getElementInArrayType(ArrayType _type, uint64 _id, uint _index) constant public returns(uint8);
function getMonsterClass(uint32 _classId) constant public returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable);
function getMonsterObj(uint64 _objId) constant public returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
function getMonsterName(uint64 _objId) constant public returns(string name);
function getExtraBalance(address _trainer) constant public returns(uint256);
function getMonsterDexSize(address _trainer) constant public returns(uint);
function getMonsterObjId(address _trainer, uint index) constant public returns(uint64);
function getExpectedBalance(address _trainer) constant public returns(uint256);
function getMonsterReturn(uint64 _objId) constant public returns(uint256 current, uint256 total);
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
contract BattleInterface {
function createCastleWithToken(address _trainer, uint32 _noBrick, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3) external;
}
contract TransformInterface {
function removeHatchingTimeWithToken(address _trainer) external;
function buyEggWithToken(address _trainer) external;
}
contract EngergyInterface {
function topupEnergyByToken(address _player, uint _packId, uint _token) external;
}
contract AdventureInterface {
function adventureByToken(address _player, uint _token, uint _param1, uint _param2, uint64 _param3, uint64 _param4) external;
}
contract EtheremonPayment is EtheremonEnum, BasicAccessControl, SafeMath {
uint8 constant public STAT_COUNT = 6;
uint8 constant public STAT_MAX = 32;
uint8 constant public GEN0_NO = 24;
enum PayServiceType {
NONE,
FAST_HATCHING,
RANDOM_EGG,
ENERGY_TOPUP,
ADVENTURE
}
struct MonsterClassAcc {
uint32 classId;
uint256 price;
uint256 returnPrice;
uint32 total;
bool catchable;
}
struct MonsterObjAcc {
uint64 monsterId;
uint32 classId;
address trainer;
string name;
uint32 exp;
uint32 createIndex;
uint32 lastClaimIndex;
uint createTime;
}
// linked smart contract
address public dataContract;
address public tokenContract;
address public transformContract;
address public energyContract;
address public adventureContract;
address private lastHunter = address(0x0);
// config
uint public fastHatchingPrice = 35 * 10 ** 8; // 15 tokens
uint public buyEggPrice = 80 * 10 ** 8; // 80 tokens
uint public tokenPrice = 0.004 ether / 10 ** 8;
uint public maxDexSize = 200;
// event
event EventCatchMonster(address indexed trainer, uint64 objId);
// modifier
modifier requireDataContract {
require(dataContract != address(0));
_;
}
modifier requireTokenContract {
require(tokenContract != address(0));
_;
}
modifier requireTransformContract {
require(transformContract != address(0));
_;
}
function EtheremonPayment(address _dataContract, address _tokenContract, address _transformContract, address _energyContract, address _adventureContract) public {
dataContract = _dataContract;
tokenContract = _tokenContract;
transformContract = _transformContract;
energyContract = _energyContract;
adventureContract = _adventureContract;
}
// helper
function getRandom(uint8 maxRan, uint8 index, address priAddress) constant public returns(uint8) {
uint256 genNum = uint256(block.blockhash(block.number-1)) + uint256(priAddress);
for (uint8 i = 0; i < index && i < 6; i ++) {
genNum /= 256;
}
return uint8(genNum % maxRan);
}
// admin
function withdrawToken(address _sendTo, uint _amount) onlyModerators requireTokenContract external {
ERC20Interface token = ERC20Interface(tokenContract);
if (_amount > token.balanceOf(address(this))) {
revert();
}
token.transfer(_sendTo, _amount);
}
function setContract(address _dataContract, address _tokenContract, address _transformContract, address _energyContract, address _adventureContract) onlyModerators external {
dataContract = _dataContract;
tokenContract = _tokenContract;
transformContract = _transformContract;
energyContract = _energyContract;
adventureContract = _adventureContract;
}
function setConfig(uint _tokenPrice, uint _maxDexSize, uint _fastHatchingPrice, uint _buyEggPrice) onlyModerators external {
tokenPrice = _tokenPrice;
maxDexSize = _maxDexSize;
fastHatchingPrice = _fastHatchingPrice;
buyEggPrice = _buyEggPrice;
}
// battle
function catchMonster(address _trainer, uint _tokens, uint32 _classId, string _name) isActive requireDataContract requireTokenContract public returns(uint){
if (msg.sender != tokenContract)
revert();
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterClassAcc memory class;
(class.classId, class.price, class.returnPrice, class.total, class.catchable) = data.getMonsterClass(_classId);
if (class.classId == 0 || class.catchable == false) {
revert();
}
// can not keep too much etheremon
if (data.getMonsterDexSize(_trainer) > maxDexSize)
revert();
uint requiredToken = class.price/tokenPrice;
if (_tokens < requiredToken)
revert();
// add monster
uint64 objId = data.addMonsterObj(_classId, _trainer, _name);
// generate base stat for the previous one
for (uint i=0; i < STAT_COUNT; i+= 1) {
uint8 value = getRandom(STAT_MAX, uint8(i), lastHunter) + data.getElementInArrayType(ArrayType.STAT_START, uint64(_classId), i);
data.addElementToArrayType(ArrayType.STAT_BASE, objId, value);
}
lastHunter = _trainer;
EventCatchMonster(_trainer, objId);
return requiredToken;
}
function _handleEnergyTopup(address _trainer, uint _param, uint _tokens) internal {
EngergyInterface energy = EngergyInterface(energyContract);
energy.topupEnergyByToken(_trainer, _param, _tokens);
}
function payService(address _trainer, uint _tokens, uint32 _type, string _text, uint64 _param1, uint64 _param2, uint64 _param3, uint64 _param4, uint64 _param5, uint64 _param6) isActive public returns(uint result) {
if (msg.sender != tokenContract)
revert();
TransformInterface transform = TransformInterface(transformContract);
if (_type == uint32(PayServiceType.FAST_HATCHING)) {
// remove hatching time
if (_tokens < fastHatchingPrice)
revert();
transform.removeHatchingTimeWithToken(_trainer);
return fastHatchingPrice;
} else if (_type == uint32(PayServiceType.RANDOM_EGG)) {
if (_tokens < buyEggPrice)
revert();
transform.buyEggWithToken(_trainer);
return buyEggPrice;
} else if (_type == uint32(PayServiceType.ENERGY_TOPUP)) {
_handleEnergyTopup(_trainer, _param1, _tokens);
return _tokens;
} else if (_type == uint32(PayServiceType.ADVENTURE)) {
AdventureInterface adventure = AdventureInterface(adventureContract);
adventure.adventureByToken(_trainer, _tokens, _param1, _param2, _param3, _param4);
return _tokens;
} else {
revert();
}
}
}
| 195,433 | 13,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.