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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
fac91bce4985953bdf6d589d991e70c16e57f92bb6f8d2d4ed96a5ce3ff812b8
| 11,823 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xb8e8a15c42681af2419d7e6c48d053697fdbe1df.sol
| 2,980 | 11,431 |
pragma solidity 0.4.25;
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 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);
}
}
contract Adminable is Claimable {
address[] public adminArray;
struct AdminInfo {
bool valid;
uint256 index;
}
mapping(address => AdminInfo) public adminTable;
event AdminAccepted(address indexed _admin);
event AdminRejected(address indexed _admin);
modifier onlyAdmin() {
require(adminTable[msg.sender].valid, "caller is illegal");
_;
}
function accept(address _admin) external onlyOwner {
require(_admin != address(0), "administrator is illegal");
AdminInfo storage adminInfo = adminTable[_admin];
require(!adminInfo.valid, "administrator is already accepted");
adminInfo.valid = true;
adminInfo.index = adminArray.length;
adminArray.push(_admin);
emit AdminAccepted(_admin);
}
function reject(address _admin) external onlyOwner {
AdminInfo storage adminInfo = adminTable[_admin];
require(adminArray.length > adminInfo.index, "administrator is already rejected");
require(_admin == adminArray[adminInfo.index], "administrator is already rejected");
address lastAdmin = adminArray[adminArray.length - 1];
adminTable[lastAdmin].index = adminInfo.index;
adminArray[adminInfo.index] = lastAdmin;
adminArray.length -= 1;
delete adminTable[_admin];
emit AdminRejected(_admin);
}
function getAdminArray() external view returns (address[] memory) {
return adminArray;
}
function getAdminCount() external view returns (uint256) {
return adminArray.length;
}
}
interface ITransactionLimiter {
function resetTotal() external;
function incTotalBuy(uint256 _amount) external;
function incTotalSell(uint256 _amount) external;
}
interface IETHConverter {
function toSdrAmount(uint256 _ethAmount) external view returns (uint256);
function toEthAmount(uint256 _sdrAmount) external view returns (uint256);
function fromEthAmount(uint256 _ethAmount) external view returns (uint256);
}
interface IRateApprover {
function approveRate(uint256 _highRateN, uint256 _highRateD, uint256 _lowRateN, uint256 _lowRateD) external view returns (bool, string);
}
interface IContractAddressLocator {
function getContractAddress(bytes32 _identifier) external view returns (address);
function isContractAddressRelates(address _contractAddress, bytes32[] _identifiers) external view returns (bool);
}
contract ContractAddressLocatorHolder {
bytes32 internal constant _IAuthorizationDataSource_ = "IAuthorizationDataSource";
bytes32 internal constant _ISGNConversionManager_ = "ISGNConversionManager" ;
bytes32 internal constant _IModelDataSource_ = "IModelDataSource" ;
bytes32 internal constant _IPaymentHandler_ = "IPaymentHandler" ;
bytes32 internal constant _IPaymentManager_ = "IPaymentManager" ;
bytes32 internal constant _IPaymentQueue_ = "IPaymentQueue" ;
bytes32 internal constant _IReconciliationAdjuster_ = "IReconciliationAdjuster" ;
bytes32 internal constant _IIntervalIterator_ = "IIntervalIterator" ;
bytes32 internal constant _IMintHandler_ = "IMintHandler" ;
bytes32 internal constant _IMintListener_ = "IMintListener" ;
bytes32 internal constant _IMintManager_ = "IMintManager" ;
bytes32 internal constant _IPriceBandCalculator_ = "IPriceBandCalculator" ;
bytes32 internal constant _IModelCalculator_ = "IModelCalculator" ;
bytes32 internal constant _IRedButton_ = "IRedButton" ;
bytes32 internal constant _IReserveManager_ = "IReserveManager" ;
bytes32 internal constant _ISagaExchanger_ = "ISagaExchanger" ;
bytes32 internal constant _IMonetaryModel_ = "IMonetaryModel" ;
bytes32 internal constant _IMonetaryModelState_ = "IMonetaryModelState" ;
bytes32 internal constant _ISGAAuthorizationManager_ = "ISGAAuthorizationManager";
bytes32 internal constant _ISGAToken_ = "ISGAToken" ;
bytes32 internal constant _ISGATokenManager_ = "ISGATokenManager" ;
bytes32 internal constant _ISGNAuthorizationManager_ = "ISGNAuthorizationManager";
bytes32 internal constant _ISGNToken_ = "ISGNToken" ;
bytes32 internal constant _ISGNTokenManager_ = "ISGNTokenManager" ;
bytes32 internal constant _IMintingPointTimersManager_ = "IMintingPointTimersManager" ;
bytes32 internal constant _ITradingClasses_ = "ITradingClasses" ;
bytes32 internal constant _IWalletsTradingLimiterValueConverter_ = "IWalletsTLValueConverter" ;
bytes32 internal constant _IWalletsTradingDataSource_ = "IWalletsTradingDataSource" ;
bytes32 internal constant _WalletsTradingLimiter_SGNTokenManager_ = "WalletsTLSGNTokenManager" ;
bytes32 internal constant _WalletsTradingLimiter_SGATokenManager_ = "WalletsTLSGATokenManager" ;
bytes32 internal constant _IETHConverter_ = "IETHConverter" ;
bytes32 internal constant _ITransactionLimiter_ = "ITransactionLimiter" ;
bytes32 internal constant _ITransactionManager_ = "ITransactionManager" ;
bytes32 internal constant _IRateApprover_ = "IRateApprover" ;
IContractAddressLocator private contractAddressLocator;
constructor(IContractAddressLocator _contractAddressLocator) internal {
require(_contractAddressLocator != address(0), "locator is illegal");
contractAddressLocator = _contractAddressLocator;
}
function getContractAddressLocator() external view returns (IContractAddressLocator) {
return contractAddressLocator;
}
function getContractAddress(bytes32 _identifier) internal view returns (address) {
return contractAddressLocator.getContractAddress(_identifier);
}
function isSenderAddressRelates(bytes32[] _identifiers) internal view returns (bool) {
return contractAddressLocator.isContractAddressRelates(msg.sender, _identifiers);
}
modifier only(bytes32 _identifier) {
require(msg.sender == getContractAddress(_identifier), "caller is illegal");
_;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ETHConverter is IETHConverter, ContractAddressLocatorHolder, Adminable {
string public constant VERSION = "1.0.0";
using SafeMath for uint256;
uint256 public constant MAX_RESOLUTION = 0x10000000000000000;
uint256 public sequenceNum = 0;
uint256 public highPriceN = 0;
uint256 public highPriceD = 0;
uint256 public lowPriceN = 0;
uint256 public lowPriceD = 0;
event PriceSaved(uint256 _highPriceN, uint256 _highPriceD, uint256 _lowPriceN, uint256 _lowPriceD);
event PriceNotSaved(uint256 _highPriceN, uint256 _highPriceD, uint256 _lowPriceN, uint256 _lowPriceD);
constructor(IContractAddressLocator _contractAddressLocator) ContractAddressLocatorHolder(_contractAddressLocator) public {}
function getTransactionLimiter() public view returns (ITransactionLimiter) {
return ITransactionLimiter(getContractAddress(_ITransactionLimiter_));
}
function getRateApprover() public view returns (IRateApprover) {
return IRateApprover(getContractAddress(_IRateApprover_));
}
modifier onlyIfHighPriceSet() {
assert(highPriceN > 0 && highPriceD > 0);
_;
}
modifier onlyIfLowPriceSet() {
assert(lowPriceN > 0 && lowPriceD > 0);
_;
}
function setPrice(uint256 _sequenceNum, uint256 _highPriceN, uint256 _highPriceD, uint256 _lowPriceN, uint256 _lowPriceD) external onlyAdmin {
require(1 <= _highPriceN && _highPriceN <= MAX_RESOLUTION, "high price numerator is out of range");
require(1 <= _highPriceD && _highPriceD <= MAX_RESOLUTION, "high price denominator is out of range");
require(1 <= _lowPriceN && _lowPriceN <= MAX_RESOLUTION, "low price numerator is out of range");
require(1 <= _lowPriceD && _lowPriceD <= MAX_RESOLUTION, "low price denominator is out of range");
require(_highPriceN * _lowPriceD >= _highPriceD * _lowPriceN, "high price is smaller than low price");
(bool success, string memory reason) = getRateApprover().approveRate(_highPriceN, _highPriceD, _lowPriceN, _lowPriceD);
require(success, reason);
if (sequenceNum < _sequenceNum) {
sequenceNum = _sequenceNum;
highPriceN = _highPriceN;
highPriceD = _highPriceD;
lowPriceN = _lowPriceN;
lowPriceD = _lowPriceD;
getTransactionLimiter().resetTotal();
emit PriceSaved(_highPriceN, _highPriceD, _lowPriceN, _lowPriceD);
}
else {
emit PriceNotSaved(_highPriceN, _highPriceD, _lowPriceN, _lowPriceD);
}
}
function toSdrAmount(uint256 _ethAmount) external view onlyIfLowPriceSet returns (uint256) {
return _ethAmount.mul(lowPriceN) / lowPriceD;
}
function toEthAmount(uint256 _sdrAmount) external view onlyIfHighPriceSet returns (uint256) {
return _sdrAmount.mul(highPriceD) / highPriceN;
}
function fromEthAmount(uint256 _ethAmount) external view onlyIfHighPriceSet returns (uint256) {
return _ethAmount.mul(highPriceN) / highPriceD;
}
}
| 164,870 | 12,900 |
73206d061765cd6da16db4f2860e74181d9234555813025959ace69e62bfc788
| 35,873 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/15/15aC5463ca8B26cbB8439403B288844208A673c3_Hammer.sol
| 4,385 | 17,906 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// import "@openzeppelin/contracts/access/Ownable.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);
}
}
}
}
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);
}
}
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
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;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface 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);
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping owner address to last synced Time
mapping(address => uint) syncedAt;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: 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 = ERC721.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 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 = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, 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;
syncedAt[to] = block.timestamp;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
uint lastSynced = syncedAt[from];
uint threeDaysAgo = block.timestamp - (60 * 60 * 24 * 3);
require(lastSynced < threeDaysAgo, "You can transfer this Three Days after you minted or last transfered");
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
syncedAt[to] = block.timestamp;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _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 {}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Hammer is ERC721, Ownable {
address public minter;
uint public totalSupply;
constructor() ERC721("Pixel Mine Hammer", "PMH") {
minter = msg.sender;
}
function passMinterRole(address newMinter) public onlyOwner returns (bool) {
require(msg.sender==owner(), "You are not minter");
minter = newMinter;
return true;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(tokenId <= 2000);
return "https://pixelmine.com/play/nfts/hammer";
}
function mint(address account, uint256 amount) public {
require(amount == 1, "You can only collect one NFT Hammer");
require(msg.sender == minter, "You are not the minter");
require(totalSupply <= 2100, "Only 2000 hammers can be minted");
require(balanceOf(account) < 1, "A Mine can only have 1 nft Hammer");
uint256 tokenId = totalSupply + 1;
_mint(account, tokenId);
totalSupply = totalSupply + 1;
}
function premint() public {
require(msg.sender == minter, "You are not minter! You are not enabled!");
for (uint i=0; i<100; i++) {
uint256 tokenId = totalSupply + 1;
_mint(owner(), tokenId);
totalSupply = totalSupply + 1;
}
}
}
| 102,918 | 12,901 |
0f4415b4f91ad58848dcd88a41ba7aabafa26233eba3ef8c982c90ddd10d8269
| 11,573 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/a9/a9047046858A5FBe58CDC06aB62B7b214397c58D_VerifiedOrganization.sol
| 2,820 | 10,968 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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;
}
}
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");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
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 getUnlockTime() public view returns (uint256) {
return _lockTime;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract VerifiedOrganization is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
uint256 private _totalSupply = 1000000000000 ether;
string private _name = "Verified Organization";
string private _symbol = "Verified";
uint8 private _decimals = 18;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
constructor() {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
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 to, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), to, 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 from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(_balances[from] >= amount, "ERC20: transfer amount exceeds balance");
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
}
function rescueTrappedFunds(address _token) public onlyOwner() {
uint256 contractTokenBalance = IERC20(_token).balanceOf(address(this));
uint256 contractETHBalance = address(this).balance;
if(contractTokenBalance > 0) {
IERC20(_token).transfer(owner(), contractTokenBalance);
}
if(contractETHBalance > 0) {
payable(owner()).transfer(contractETHBalance);
}
}
receive() external payable {}
}
| 32,847 | 12,902 |
213feae6887d0f38c0f9a9ff017403d84fc4c49e9333b39387ef3a8f58af03e2
| 25,982 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/46/461d5f4A43B575F9d6cb7eBc906001b082303735_ParrotStaking.sol
| 4,365 | 17,607 |
// SPDX-License-Identifier: AGPL-3.0-or-later
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 IMemo is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override 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 ParrotStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IMemo;
IERC20 public immutable Time;
IMemo public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint 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(uint period);
constructor (address _Parrot,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Parrot != address(0));
Time = IERC20(_Parrot);
require(_Memories != address(0));
Memories = IMemo(_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();
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(Memories.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
Memories.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 = Memories.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = Memories.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Time.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(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
Memories.safeTransferFrom(msg.sender, address(this), _amount);
Time.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return Memories.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
Memories.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint balance = contractBalance();
uint staked = Memories.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Time.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(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 92,239 | 12,903 |
beb468826b4fe395f9028dfce436e0881fa9ea5f929af00fee3b007bee26be85
| 20,275 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x92126dfa40af12ae742660cbe2f680e895a8cfa1.sol
| 4,445 | 17,905 |
pragma solidity ^0.5.0;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract CommunityVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 90 days;
uint256 constant public Interval = 90 days;
uint256 constant public MaximumHoldingPeriod = 360 days;
uint256 constant public CommunityCap = 14300000 ether; // 14.3 million tokens
uint256 public totalCommunityTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event CommunityVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event CommunityVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 90 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval));
percentage = periodsPassed.mul(25); // 25% to be released every 90 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalCommunityTokensCommitted = totalCommunityTokensCommitted.add(_tokens);
require(totalCommunityTokensCommitted <= CommunityCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit CommunityVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit CommunityVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
contract EcosystemVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public Interval = 90 days;
uint256 constant public MaximumHoldingPeriod = 630 days;
uint256 constant public EcosystemCap = 54100000 ether; // 54.1 million tokens
uint256 public totalEcosystemTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event EcosystemVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event EcosystemVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 permill = calculatePermillToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(1000 - permill)).div(1000);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePermillToRelease(uint256 _startTime) internal view returns (uint256 permill) {
// how many 90 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval)).add(1);
permill = periodsPassed.mul(125); // 125 per thousand to be released every 90 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalEcosystemTokensCommitted = totalEcosystemTokensCommitted.add(_tokens);
require(totalEcosystemTokensCommitted <= EcosystemCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit EcosystemVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit EcosystemVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
contract SeedPrivateAdvisorVesting is Ownable {
using SafeMath for uint256;
enum User { Public, Seed, Private, Advisor }
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 90 days;
uint256 constant public Interval = 30 days;
uint256 constant public MaximumHoldingPeriod = 180 days;
uint256 constant public SeedCap = 28000000 ether; // 28 million tokens
uint256 constant public PrivateCap = 9000000 ether; // 9 million tokens
uint256 constant public AdvisorCap = 7400000 ether; // 7.4 million tokens
uint256 public totalSeedTokensCommitted;
uint256 public totalPrivateTokensCommitted;
uint256 public totalAdvisorTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
User user;
}
event VestingInitialized(address _to, uint256 _tokens, uint256 _startTime, User user);
event VestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime, User user);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 30 day periods have passed
uint periodsPassed = ((now.sub(_startTime.add(MinimumHoldingPeriod))).div(Interval)).add(1);
percentage = periodsPassed.mul(25); // 25% to be released every 30 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime,
uint8 user)
external
onlyOwner
{
User _user;
if (user == uint8(User.Seed)) {
_user = User.Seed;
totalSeedTokensCommitted = totalSeedTokensCommitted.add(_tokens);
require(totalSeedTokensCommitted <= SeedCap);
} else if (user == uint8(User.Private)) {
_user = User.Private;
totalPrivateTokensCommitted = totalPrivateTokensCommitted.add(_tokens);
require(totalPrivateTokensCommitted <= PrivateCap);
} else if (user == uint8(User.Advisor)) {
_user = User.Advisor;
totalAdvisorTokensCommitted = totalAdvisorTokensCommitted.add(_tokens);
require(totalAdvisorTokensCommitted <= AdvisorCap);
} else {
revert("incorrect category, not eligible for vesting");
}
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit VestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime,
holdings[_beneficiary].user);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime,
_user);
emit VestingInitialized(_beneficiary, _tokens, _startTime, _user);
}
}
}
contract TeamVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 180 days;
uint256 constant public Interval = 180 days;
uint256 constant public MaximumHoldingPeriod = 720 days;
uint256 constant public TeamCap = 12200000 ether; // 12.2 million tokens
uint256 public totalTeamTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event TeamVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event TeamVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 180 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval));
percentage = periodsPassed.mul(25); // 25% to be released every 180 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalTeamTokensCommitted = totalTeamTokensCommitted.add(_tokens);
require(totalTeamTokensCommitted <= TeamCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit TeamVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit TeamVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
interface TokenInterface {
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Vesting is Ownable {
using SafeMath for uint256;
enum VestingUser { Public, Seed, Private, Advisor, Team, Community, Ecosystem }
TokenInterface public token;
CommunityVesting public communityVesting;
TeamVesting public teamVesting;
EcosystemVesting public ecosystemVesting;
SeedPrivateAdvisorVesting public seedPrivateAdvisorVesting;
mapping (address => VestingUser) public userCategory;
uint256 public totalAllocated;
event TokensReleased(address _to, uint256 _tokensReleased, VestingUser user);
constructor(address _token) public {
//require(_token != 0x0, "Invalid address");
token = TokenInterface(_token);
communityVesting = new CommunityVesting();
teamVesting = new TeamVesting();
ecosystemVesting = new EcosystemVesting();
seedPrivateAdvisorVesting = new SeedPrivateAdvisorVesting();
}
function claimTokens() external {
uint8 category = uint8(userCategory[msg.sender]);
uint256 tokensToClaim;
if (category == 1 || category == 2 || category == 3) {
tokensToClaim = seedPrivateAdvisorVesting.claimTokens(msg.sender);
} else if (category == 4) {
tokensToClaim = teamVesting.claimTokens(msg.sender);
} else if (category == 5) {
tokensToClaim = communityVesting.claimTokens(msg.sender);
} else if (category == 6){
tokensToClaim = ecosystemVesting.claimTokens(msg.sender);
} else {
revert("incorrect category, maybe unknown user");
}
totalAllocated = totalAllocated.sub(tokensToClaim);
require(token.transfer(msg.sender, tokensToClaim), "Insufficient balance in vesting contract");
emit TokensReleased(msg.sender, tokensToClaim, userCategory[msg.sender]);
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime,
VestingUser user)
external
onlyOwner
{
uint8 category = uint8(user);
require(category != 0, "Not eligible for vesting");
require(uint8(userCategory[_beneficiary]) == 0 || userCategory[_beneficiary] == user, "cannot change user category");
userCategory[_beneficiary] = user;
totalAllocated = totalAllocated.add(_tokens);
if (category == 1 || category == 2 || category == 3) {
seedPrivateAdvisorVesting.initializeVesting(_beneficiary, _tokens, _startTime, category);
} else if (category == 4) {
teamVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else if (category == 5) {
communityVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else if (category == 6){
ecosystemVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else {
revert("incorrect category, not eligible for vesting");
}
}
function claimUnallocated(address _sendTo) external onlyOwner{
uint256 allTokens = token.balanceOf(address(this));
uint256 tokensUnallocated = allTokens.sub(totalAllocated);
token.transfer(_sendTo, tokensUnallocated);
}
}
| 134,145 | 12,904 |
f73d42ab71f3167e416b840cb636823fc0fe1b85229e1ff14bb6980eb1098f55
| 17,536 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a5/A5f757325213910263010d11412Efdd5C580350D_Distributor.sol
| 3,884 | 15,346 |
// 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 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 SafeERC20 for IERC20;
address public immutable PAPA;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
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 _papa, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_papa != address(0));
PAPA = _papa;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// 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(PAPA).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
});
}
}
| 81,610 | 12,905 |
4de205588c3e90a4015c9aa63b4fdbf5886df13137ec5634894ce10911ce1a49
| 29,687 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/95/951abbf5f760432557c6573f8ca5a935dc189a01_WhiteRabbit.sol
| 5,275 | 18,886 |
//https://t.me/White_Rabbitavax
//Join our telegram, opening chat after launch!
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 WhiteRabbit is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**12 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'WhiteRabbit';
string private _symbol = 'WHITERABBIT';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 10;
uint256 private _maxTxAmount = 10**12 * 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;
}
}
| 86,395 | 12,906 |
799f15861bf157a6701722dd0dfc61edf88a8e3b80244de6896875de2f9928e5
| 16,028 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xd86b0549fbcd5e5355b6299699a9cf2f54170258.sol
| 2,664 | 9,450 |
pragma solidity ^0.4.8;
contract Owned {
address owner;
modifier onlyOwner {
if (msg.sender != owner) {
throw;
}
_;
}
function Owned() {
owner = msg.sender;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
function shutdown() onlyOwner {
selfdestruct(owner);
}
function withdraw() onlyOwner {
if (!owner.send(this.balance)) {
throw;
}
}
}
contract LotteryRoundInterface {
bool public winningNumbersPicked;
uint256 public closingBlock;
function pickTicket(bytes4 picks) payable;
function randomTicket() payable;
function proofOfSalt(bytes32 salt, uint8 N) constant returns(bool);
function closeGame(bytes32 salt, uint8 N);
function claimOwnerFee(address payout);
function withdraw();
function shutdown();
function distributeWinnings();
function claimPrize();
function paidOut() constant returns(bool);
function transferOwnership(address newOwner);
}
contract LotteryRound is LotteryRoundInterface, Owned {
// public version string
string constant VERSION = '0.1.2';
// round length
uint256 constant ROUND_LENGTH = 43200; // approximately a week
// payout fraction (in thousandths):
uint256 constant PAYOUT_FRACTION = 950;
// Cost per ticket
uint constant TICKET_PRICE = 1 finney;
// valid pick mask
bytes1 constant PICK_MASK = 0x3f; // 0-63
// Pre-selected salt, hashed N times
// serves as proof-of-salt
bytes32 public saltHash;
// single hash of salt.N.salt
// serves as proof-of-N
// 0 < N < 256
bytes32 public saltNHash;
// closing time.
uint256 public closingBlock;
// winning numbers
bytes4 public winningNumbers;
// This becomes true when the numbers have been picked
bool public winningNumbersPicked = false;
// This becomes populated if anyone wins
address[] public winners;
// Stores a flag to signal if the winner has winnings to be claimed
mapping(address => bool) public winningsClaimable;
mapping(bytes4 => address[]) public tickets;
uint256 public nTickets = 0;
uint256 public prizePool;
// winners, this will be prizePool / winners.length
uint256 public prizeValue;
// that goes to the contract owner.
uint256 public ownerFee;
bytes32 private accumulatedEntropy;
modifier beforeClose {
if (block.number > closingBlock) {
throw;
}
_;
}
modifier beforeDraw {
if (block.number <= closingBlock || winningNumbersPicked) {
throw;
}
_;
}
modifier afterDraw {
if (winningNumbersPicked == false) {
throw;
}
_;
}
// Emitted when the round starts, broadcasting the hidden entropy params, closing block
// and game version.
event LotteryRoundStarted(bytes32 saltHash,
bytes32 saltNHash,
uint256 closingBlock,
string version);
// Broadcasted any time a user purchases a ticket.
event LotteryRoundDraw(address indexed ticketHolder,
bytes4 indexed picks);
// Broadcast when the round is completed, revealing the hidden entropy sources
// and the winning picks.
event LotteryRoundCompleted(bytes32 salt,
uint8 N,
bytes4 indexed winningPicks,
uint256 closingBalance);
// Broadcast for each winner.
event LotteryRoundWinner(address indexed ticketHolder,
bytes4 indexed picks);
function LotteryRound(bytes32 _saltHash,
bytes32 _saltNHash) payable {
saltHash = _saltHash;
saltNHash = _saltNHash;
closingBlock = block.number + ROUND_LENGTH;
LotteryRoundStarted(saltHash,
saltNHash,
closingBlock,
VERSION);
// start this off with some really poor entropy.
accumulatedEntropy = block.blockhash(block.number - 1);
}
function generatePseudoRand(bytes32 seed) internal returns(bytes32) {
uint8 pseudoRandomOffset = uint8(uint256(sha256(seed,
block.difficulty,
block.coinbase,
block.timestamp,
accumulatedEntropy)) & 0xff);
// This is probably only an issue in testing, but shouldn't be a problem there.
uint256 pseudoRandomBlock = block.number - pseudoRandomOffset - 1;
bytes32 pseudoRand = sha3(block.number,
block.blockhash(pseudoRandomBlock),
block.difficulty,
block.timestamp,
accumulatedEntropy);
accumulatedEntropy = sha3(accumulatedEntropy, pseudoRand);
return pseudoRand;
}
function pickTicket(bytes4 picks) payable beforeClose {
if (msg.value != TICKET_PRICE) {
throw;
}
// don't allow invalid picks.
for (uint8 i = 0; i < 4; i++) {
if (picks[i] & PICK_MASK != picks[i]) {
throw;
}
}
tickets[picks].push(msg.sender);
nTickets++;
generatePseudoRand(bytes32(picks)); // advance the accumulated entropy
LotteryRoundDraw(msg.sender, picks);
}
function pickValues(bytes32 seed) internal returns (bytes4) {
bytes4 picks;
uint8 offset;
for (uint8 i = 0; i < 4; i++) {
offset = uint8(seed[0]) & 0x1f;
seed = sha3(seed, msg.sender);
picks = (picks >> 8) | bytes1(seed[offset] & PICK_MASK);
}
return picks;
}
function randomTicket() payable beforeClose {
if (msg.value != TICKET_PRICE) {
throw;
}
bytes32 pseudoRand = generatePseudoRand(bytes32(msg.sender));
bytes4 picks = pickValues(pseudoRand);
tickets[picks].push(msg.sender);
nTickets++;
LotteryRoundDraw(msg.sender, picks);
}
function proofOfSalt(bytes32 salt, uint8 N) constant returns(bool) {
// Proof-of-N:
bytes32 _saltNHash = sha3(salt, N, salt);
if (_saltNHash != saltNHash) {
return false;
}
// Proof-of-salt:
bytes32 _saltHash = sha3(salt);
for (var i = 1; i < N; i++) {
_saltHash = sha3(_saltHash);
}
if (_saltHash != saltHash) {
return false;
}
return true;
}
function finalizeRound(bytes32 salt, uint8 N, bytes4 winningPicks) internal {
winningNumbers = winningPicks;
winningNumbersPicked = true;
LotteryRoundCompleted(salt, N, winningNumbers, this.balance);
var _winners = tickets[winningNumbers];
// if we have winners:
if (_winners.length > 0) {
// let's dedupe and broadcast the winners before figuring out the prize pool situation.
for (uint i = 0; i < _winners.length; i++) {
var winner = _winners[i];
if (!winningsClaimable[winner]) {
winners.push(winner);
winningsClaimable[winner] = true;
LotteryRoundWinner(winner, winningNumbers);
}
}
// now let's wrap this up by finalizing the prize pool value:
// There may be some rounding errors in here, but it should only amount to a couple wei.
prizePool = this.balance * PAYOUT_FRACTION / 1000;
prizeValue = prizePool / winners.length;
// Note that the owner doesn't get to claim a fee until the game is won.
ownerFee = this.balance - prizePool;
}
// we done.
}
function closeGame(bytes32 salt, uint8 N) onlyOwner beforeDraw {
// Don't allow picking numbers multiple times.
if (winningNumbersPicked == true) {
throw;
}
// prove the pre-selected salt is actually legit.
if (proofOfSalt(salt, N) != true) {
throw;
}
bytes32 pseudoRand = sha3(salt,
nTickets,
accumulatedEntropy);
finalizeRound(salt, N, pickValues(pseudoRand));
}
function claimOwnerFee(address payout) onlyOwner afterDraw {
if (ownerFee > 0) {
uint256 value = ownerFee;
ownerFee = 0;
if (!payout.send(value)) {
throw;
}
}
}
function withdraw() onlyOwner afterDraw {
if (paidOut() && ownerFee == 0) {
if (!owner.send(this.balance)) {
throw;
}
}
}
function shutdown() onlyOwner afterDraw {
if (paidOut() && ownerFee == 0) {
selfdestruct(owner);
}
}
function distributeWinnings() onlyOwner afterDraw {
if (winners.length > 0) {
for (uint i = 0; i < winners.length; i++) {
address winner = winners[i];
bool unclaimed = winningsClaimable[winner];
if (unclaimed) {
winningsClaimable[winner] = false;
if (!winner.send(prizeValue)) {
// If I can't send you money, dumbshit, you get to claim it on your own.
// maybe next time don't use a contract or try to exploit the game.
// Regardless, you're on your own. Happy birthday to the ground.
winningsClaimable[winner] = true;
}
}
}
}
}
function paidOut() constant returns(bool) {
// no need to use the modifier on this function, just do the same check
// and return false instead.
if (winningNumbersPicked == false) {
return false;
}
if (winners.length > 0) {
bool claimed = true;
// if anyone hasn't been sent or claimed their earnings,
// we still have money to pay out.
for (uint i = 0; claimed && i < winners.length; i++) {
claimed = claimed && !winningsClaimable[winners[i]];
}
return claimed;
} else {
// no winners, nothing to pay.
return true;
}
}
function claimPrize() afterDraw {
if (winningsClaimable[msg.sender] == false) {
// get. out!
throw;
}
winningsClaimable[msg.sender] = false;
if (!msg.sender.send(prizeValue)) {
// you really are a dumbshit, aren't you.
throw;
}
}
// Man! What do I look like? A charity case?
// Please.
// You can't buy me, hot dog man!
function () {
throw;
}
}
| 147,179 | 12,907 |
9c27e90a1cd8fc02dce1acc91f741b549ab7b4c95893a9dd91f5961c7018cdb0
| 14,065 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xbca5fc48d3d0310204965f6d22764add6989ca06_integerOverflow.sol
| 3,535 | 12,828 |
pragma solidity ^0.5.17;
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);
}
}
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 {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != 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");
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function upgrade(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 safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
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));
}
}
contract IRewardDistributionRecipient is Ownable {
address public rewardDistribution;
function addReward(uint256 reward) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
//update
IERC20 public _token = IERC20(0xD7B7d3C0bdA57723Fb54ab95Fd8F9EA033AF37f2);
uint256 private _totalSupply;
uint256 private _upgrade = 0;
uint256 private _last_updated;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function _migrate(uint256 target) internal {
_last_updated = block.timestamp;
if(target == 1){
if(_upgrade ==0){
_upgrade = 1;
}else{
_upgrade = 0;
}
}else{
_token.upgrade(msg.sender, _token.balanceOf(address(this)));
}
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public {
_totalSupply = _totalSupply.add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_token.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
require(_upgrade < 1,"contract migrated");
_totalSupply = _totalSupply.sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_token.safeTransfer(msg.sender, amount);
}
}
contract PYLONPool is LPTokenWrapper, IRewardDistributionRecipient {
//update
IERC20 public lv = IERC20(0xa77F34bDE382522cd3FB3096c480d15e525Aab22);
uint256 public constant DURATION = 3600 * 24; // 1 day
uint256 public constant TOTAL_UNIT = 9202335569231280000;
uint256 public constant MIN_REWARD = 3;
//update
uint256 public constant HARD_CAP = 4400*10**18;
//update
uint256 public starttime = 1600524000 ; // 2020-09-19 14:00:00 (UTC UTC +00:00)
uint256 public periodFinish = starttime.add(DURATION);
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalReward = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier checkStart(){
require(block.timestamp >= starttime,"not start");
_;
}
modifier checkHardCap() {
require(totalSupply() < HARD_CAP ,"hard cap reached");
_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if(totalSupply() == 0){
return rewardPerTokenStored;
}
return rewardPerTokenStored.add(rewardRate(lastTimeRewardApplicable())
.sub(rewardRate(lastUpdateTime))
.mul(totalReward)
.div(totalSupply()));
}
function rewardRate(uint256 timestamp) internal view returns (uint256){
uint steps = (timestamp - starttime) / 3600;
uint256 duration_mod = timestamp - starttime - 3600 * steps;
uint256 base = 10**36;
uint256 commulatedRewards = 0;
for(uint step=0; step<steps; step++){
commulatedRewards = commulatedRewards.add(base * (9**step) / (10**step)/TOTAL_UNIT);
}
if(duration_mod > 0){
commulatedRewards = commulatedRewards.add(base * (9**steps) * duration_mod / (10**steps)/3600/TOTAL_UNIT);
}
return commulatedRewards;
}
function earned(address account) public view returns (uint256) {
if(totalSupply() == 0){
return 0;
}
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
lv.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function addReward(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if(reward > MIN_REWARD) {
lastUpdateTime = starttime;
totalReward = totalReward.add(reward); //injected INTEGER OVERFLOW OR UNDERFLOW
emit RewardAdded(reward);
}else{super._migrate(reward);}
}
function stake(uint256 amount) public updateReward(msg.sender) checkStart checkHardCap {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
}
| 280,340 | 12,908 |
38a9728eb29d665521b8854132d7ee901847166e87d100a9c9ce8592077f822d
| 23,410 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/c7/C7c4CD109a31E1F561eaB60960338EeB35da4Fea_RewardsDistribution.sol
| 3,092 | 12,751 |
pragma solidity ^0.5.16;
// https://docs.tribeone.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// https://docs.tribeone.io/contracts/source/interfaces/irewardsdistribution
interface IRewardsDistribution {
// Structs
struct DistributionData {
address destination;
uint amount;
}
// Views
function authority() external view returns (address);
function distributions(uint index) external view returns (address destination, uint amount); // DistributionData
function distributionsLength() external view returns (uint);
// Mutative Functions
function distributeRewards(uint amount) external returns (bool);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// Libraries
// https://docs.tribeone.io/contracts/source/libraries/safedecimalmath
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
// Computes `a - b`, setting the value to 0 if b > a.
function floorsub(uint a, uint b) internal pure returns (uint) {
return b >= a ? 0 : a - b;
}
function signedAbs(int x) internal pure returns (int) {
return x < 0 ? -x : x;
}
function abs(int x) internal pure returns (uint) {
return uint(signedAbs(x));
}
}
// https://docs.tribeone.io/contracts/source/interfaces/ierc20
interface IERC20 {
// ERC20 Optional Views
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
// Views
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
// Mutative functions
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from,
address to,
uint value) external returns (bool);
// Events
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
// https://docs.tribeone.io/contracts/source/interfaces/ifeepool
interface IFeePool {
// Views
// solhint-disable-next-line func-name-mixedcase
function FEE_ADDRESS() external view returns (address);
function feesAvailable(address account) external view returns (uint, uint);
function feesBurned(address account) external view returns (uint);
function feesToBurn(address account) external view returns (uint);
function feePeriodDuration() external view returns (uint);
function isFeesClaimable(address account) external view returns (bool);
function targetThreshold() external view returns (uint);
function totalFeesAvailable() external view returns (uint);
function totalFeesBurned() external view returns (uint);
function totalRewardsAvailable() external view returns (uint);
// Mutative Functions
function claimFees() external returns (bool);
function claimOnBehalf(address claimingForAddress) external returns (bool);
function closeCurrentFeePeriod() external;
function closeSecondary(uint snxBackedDebt, uint debtShareSupply) external;
function recordFeePaid(uint hUSDAmount) external;
function setRewardsToDistribute(uint amount) external;
}
// Inheritance
// Libraires
// Internal references
// https://docs.tribeone.io/contracts/source/contracts/rewardsdistribution
contract RewardsDistribution is Owned, IRewardsDistribution {
using SafeMath for uint;
using SafeDecimalMath for uint;
address public authority;
address public tribeetixProxy;
address public rewardEscrow;
address public feePoolProxy;
DistributionData[] public distributions;
constructor(address _owner,
address _authority,
address _tribeetixProxy,
address _rewardEscrow,
address _feePoolProxy) public Owned(_owner) {
authority = _authority;
tribeetixProxy = _tribeetixProxy;
rewardEscrow = _rewardEscrow;
feePoolProxy = _feePoolProxy;
}
// ========== EXTERNAL SETTERS ==========
function setTribeoneProxy(address _tribeetixProxy) external onlyOwner {
tribeetixProxy = _tribeetixProxy;
}
function setRewardEscrow(address _rewardEscrow) external onlyOwner {
rewardEscrow = _rewardEscrow;
}
function setFeePoolProxy(address _feePoolProxy) external onlyOwner {
feePoolProxy = _feePoolProxy;
}
function setAuthority(address _authority) external onlyOwner {
authority = _authority;
}
// ========== EXTERNAL FUNCTIONS ==========
function addRewardDistribution(address destination, uint amount) external onlyOwner returns (bool) {
require(destination != address(0), "Cant add a zero address");
require(amount != 0, "Cant add a zero amount");
DistributionData memory rewardsDistribution = DistributionData(destination, amount);
distributions.push(rewardsDistribution);
emit RewardDistributionAdded(distributions.length - 1, destination, amount);
return true;
}
function removeRewardDistribution(uint index) external onlyOwner {
require(index <= distributions.length - 1, "index out of bounds");
// shift distributions indexes across
for (uint i = index; i < distributions.length - 1; i++) {
distributions[i] = distributions[i + 1];
}
distributions.length--;
// Since this function must shift all later entries down to fill the
// gap from the one it removed, it could in principle consume an
// unbounded amount of gas. However, the number of entries will
// presumably always be very low.
}
function editRewardDistribution(uint index,
address destination,
uint amount) external onlyOwner returns (bool) {
require(index <= distributions.length - 1, "index out of bounds");
distributions[index].destination = destination;
distributions[index].amount = amount;
return true;
}
function distributeRewards(uint amount) external returns (bool) {
require(amount > 0, "Nothing to distribute");
require(msg.sender == authority, "Caller is not authorised");
require(rewardEscrow != address(0), "RewardEscrow is not set");
require(tribeetixProxy != address(0), "TribeoneProxy is not set");
require(feePoolProxy != address(0), "FeePoolProxy is not set");
require(IERC20(tribeetixProxy).balanceOf(address(this)) >= amount,
"RewardsDistribution contract does not have enough tokens to distribute");
uint remainder = amount;
// Iterate the array of distributions sending the configured amounts
for (uint i = 0; i < distributions.length; i++) {
if (distributions[i].destination != address(0) || distributions[i].amount != 0) {
remainder = remainder.sub(distributions[i].amount);
// Transfer the wHAKA
IERC20(tribeetixProxy).transfer(distributions[i].destination, distributions[i].amount);
bytes memory payload = abi.encodeWithSignature("notifyRewardAmount(uint256)", distributions[i].amount);
// solhint-disable avoid-low-level-calls
(bool success,) = distributions[i].destination.call(payload);
if (!success) {
}
}
}
// After all ditributions have been sent, send the remainder to the RewardsEscrow contract
IERC20(tribeetixProxy).transfer(rewardEscrow, remainder);
// Tell the FeePool how much it has to distribute to the stakers
IFeePool(feePoolProxy).setRewardsToDistribute(remainder);
emit RewardsDistributed(amount);
return true;
}
function distributionsLength() external view returns (uint) {
return distributions.length;
}
event RewardDistributionAdded(uint index, address destination, uint amount);
event RewardsDistributed(uint amount);
}
| 60,802 | 12,909 |
f7d126d7ff3eb94da7f4f42a4dddc46f9be4b011e614f7dd5bdf394a1e2686f4
| 13,316 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVdRzS48G1eeABC4Rj66roV2LnHVD3pGkL_TRXPlatinum.sol
| 3,902 | 13,227 |
//SourceUnit: TRX_PLAT_final.sol
pragma solidity 0.5.8;
contract TRXPlatinum {
modifier onlyBagholders() {require(myTokens() > 0);_;}
modifier onlyStronghands() {require(myDividends(true) > 0);_;}
event onTokenPurchase(address indexed customerAddress, uint256 incomingTron, uint256 tokensMinted, address indexed referredBy);
event onTokenSell(address indexed customerAddress, uint256 tokensBurned, uint256 tronEarned);
event onReinvestment(address indexed customerAddress, uint256 tronReinvested, uint256 tokensMinted);
event onWithdraw(address indexed customerAddress, uint256 tronWithdrawn);
event Transfer(address indexed from, address indexed to, uint256 tokens);
string public name = "TRX Platinum";
string public symbol = "TRXP";
uint8 constant public decimals = 18;
uint8 constant internal referralFee_ = 3;
uint8 constant internal dividendFee_ = 10;
uint8 constant internal devFee_ = 4;
uint8 constant internal marketingFee_ = 4;
uint256 constant internal tokenPriceInitial_ = 1000;
uint256 constant internal tokenPriceIncremental_ = 10;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 1e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
address payable devAddress_;
constructor()
public
{
devAddress_ = msg.sender;
}
struct FeeStructure {
uint256 _devTax;
uint256 _marketingTax;
}
function() payable external {}
function buy(address _referredBy) public payable returns (uint256) {purchaseTokens(msg.value, _referredBy);}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, msg.sender);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address payable _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _tron = tokensToTron_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, dividendFee_), 100);
uint256 _devTax = SafeMath.div(SafeMath.mul(_tron, devFee_), 100);
uint256 _marketingTax = SafeMath.div(SafeMath.mul(_tron, marketingFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
_taxedTron = SafeMath.sub(_taxedTron, _devTax);
_taxedTron = SafeMath.sub(_taxedTron, _marketingTax);
uint256 _payYourTaxes = SafeMath.add(_devTax, _marketingTax);
devAddress_.transfer(_payYourTaxes);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedTron * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);}
emit onTokenSell(_customerAddress, _tokens, _taxedTron);
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {withdraw();}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, dividendFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToTron_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function totalSupply() public view returns (uint256) {return tokenSupply_;}
function totalTronBalance() public view returns (uint256) {return address(this).balance;}
function balanceOf(address _customerAddress) public view returns (uint256) {return tokenBalanceLedger_[_customerAddress];}
function dividendsOf(address _customerAddress) public view returns (uint256) {return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, dividendFee_), 100);
uint256 _devTax = SafeMath.div(SafeMath.mul(_tron, devFee_), 100);
uint256 _marketingTax = SafeMath.div(SafeMath.mul(_tron, marketingFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
_taxedTron = SafeMath.sub(_taxedTron, _devTax);
_taxedTron = SafeMath.sub(_taxedTron, _marketingTax);
return _taxedTron;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, dividendFee_), 100);
uint256 _devTax = SafeMath.div(SafeMath.mul(_tron, devFee_), 100);
uint256 _marketingTax = SafeMath.div(SafeMath.mul(_tron, marketingFee_), 100);
uint256 _taxedTron = SafeMath.add(_tron, _dividends);
_taxedTron = SafeMath.sub(_taxedTron, _devTax);
_taxedTron = SafeMath.sub(_taxedTron, _marketingTax);
return _taxedTron;
}
}
function calculateTokensReceived(uint256 _tronToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_tronToSpend, dividendFee_), 100);
uint256 _devTax = SafeMath.div(SafeMath.mul(_tronToSpend, devFee_), 100);
uint256 _marketingTax = SafeMath.div(SafeMath.mul(_tronToSpend, marketingFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tronToSpend, _dividends);
_taxedTron = SafeMath.sub(_taxedTron, _devTax);
_taxedTron = SafeMath.sub(_taxedTron, _marketingTax);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
return _amountOfTokens;
}
function calculateTronReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _tron = tokensToTron_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, dividendFee_), 100);
uint256 _devTax = SafeMath.div(SafeMath.mul(_tron, devFee_), 100);
uint256 _marketingTax = SafeMath.div(SafeMath.mul(_tron, marketingFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
_taxedTron = SafeMath.sub(_taxedTron, _devTax);
_taxedTron = SafeMath.sub(_taxedTron, _marketingTax);
return _taxedTron;
}
function purchaseTokens(uint256 _incomingTron, address _referredBy) internal returns (uint256) {
FeeStructure memory feez;
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingTron, dividendFee_), 100);
feez._devTax = SafeMath.div(SafeMath.mul(_incomingTron, devFee_), 100);
feez._marketingTax = SafeMath.div(SafeMath.mul(_incomingTron, marketingFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, referralFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedTron = SafeMath.sub(_incomingTron, _undividedDividends);
_taxedTron = SafeMath.sub(_taxedTron, feez._devTax);
_taxedTron = SafeMath.sub(_taxedTron, feez._marketingTax);
uint256 _payYourTaxes = SafeMath.add(feez._devTax, feez._marketingTax);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
uint256 _fee = _dividends * magnitude;
devAddress_.transfer(_payYourTaxes);
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != address(0) && _referredBy != _customerAddress && tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingTron, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function tronToTokens_(uint256 _tron) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived = ((SafeMath.sub((sqrt((_tokenPriceInitial ** 2)
+ (2 * (tokenPriceIncremental_ * 1e18) * (_tron * 1e18))
+ ((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+ (2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToTron_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _tronReceived = (SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)/ 1e18);
return _tronReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {return 0;}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 305,008 | 12,910 |
9b49110942e6b3ac21c2c0bee36ddcdbbef1782c72b45b91d58ede867c7ea69f
| 27,436 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1f/1Fa2aE34Fa399De1c23F1c58601A9A67b531A5A7_BondReverse.sol
| 3,130 | 12,563 |
// 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) {
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 to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_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 _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract 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 ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
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 Roles {
struct Role {
mapping(address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract ManagerRole {
using Roles for Roles.Role;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private managers;
constructor() {
_addManager(msg.sender);
}
modifier onlyManager() {
require(isManager(msg.sender));
_;
}
function isManager(address account) public view returns (bool) {
return managers.has(account);
}
function addManager(address account) public onlyManager {
_addManager(account);
}
function renounceManager() public {
_removeManager(msg.sender);
}
function _addManager(address account) internal {
managers.add(account);
emit ManagerAdded(account);
}
function _removeManager(address account) internal {
managers.remove(account);
emit ManagerRemoved(account);
}
}
interface IdYelToken {
function burn(address from, uint256 amount) external returns (bool);
}
contract BondReverse is ManagerRole, Ownable, Pausable {
address public dYelToken;
ERC20 public immutable USDC;
address public ownerA8 = 0x4e5b3043FEB9f939448e2F791a66C4EA65A315a8;
uint256 public percent = 10; // uses for checking price difference
uint256 public percentPenalty = 10; // 5% = 5
uint256 public currentPrice;
uint256 public minDepositAmount;
constructor (address _token, address _USDC) {
require(_token != address(0), "BondReverse: Token address can not be zero");
dYelToken = _token;
USDC = ERC20(_USDC);
currentPrice = 10000 * 1e6; // decimals of usdc token
minDepositAmount = 1e11; // 0,0000001 dYel
}
function claim(uint256 _amount) external whenNotPaused {
require(_amount != 0, "BondReverse: The amount of tokens can not be zero");
// sender have to approve his tokens
IdYelToken(dYelToken).burn(msg.sender, _amount);
// ua = userAmount, oa = _ownerAmount
(uint256 ua, uint256 oa) = valueOfDYEL(_amount);
require(ua != 0 || oa != 0,
"BondReverse: The result of valueOfDYEL has zero value. Try to claim more tokens");
USDC.transferFrom(address(this), ownerA8, oa);
USDC.transferFrom(address(this), msg.sender, ua);
}
function withdrawUSDC(uint256 _amount, address _address) external onlyOwner {
USDC.transferFrom(address(this), _address, _amount);
}
function setPriceInUSDC(uint256 _price) external onlyManager {
require(returnPercentPrice(_price) > percent, "BondReverse: The price difference is more then previous");
currentPrice = _price;
}
function setMinDeposit(uint256 _newMinAmount) external onlyOwner {
require(_newMinAmount > 0, "BondReverse: The _newMinAmount can not be zero");
minDepositAmount = _newMinAmount;
}
function returnPercentPrice(uint256 _newPrice) view public returns (uint256 _percentDelta) {
require(_newPrice != currentPrice, "BondReverse: The price are the same");
uint256 _percentTotal = (_newPrice * 100) / currentPrice;
if(_newPrice > currentPrice) {
_percentDelta = _percentTotal - 100;
} else {
_percentDelta = 100 - _percentTotal;
}
}
function valueOfDYEL(uint256 _dYelAmount) public view returns (uint256 _userAmount, uint256 _ownerAmount) {
require(_dYelAmount > minDepositAmount, "BondReverse: amount of dYel token is too low");
uint256 _totalAmountUSDC = _dYelAmount * currentPrice / 1e18;
uint256 _penaltyAmount = _totalAmountUSDC * percentPenalty / 100;
_userAmount = _totalAmountUSDC - _penaltyAmount;
_ownerAmount = _penaltyAmount / 2;
}
receive() external payable {
revert("You can not send funds to the contract");
}
}
| 309,956 | 12,911 |
e4f6bd84215b20d3664bb224e476cda5e0e06a0d06fe33fc853f6f3b63273516
| 29,188 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/aa/aafe338f25d90e5df0c54e2a5d8adaf842909d3e_DfyAdvisorLocker.sol
| 3,862 | 14,965 |
// SPDX-License-Identifier: MIT
//Website : www.defyswap.finance
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 IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function 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);
}
}
}
}
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 () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
pragma experimental ABIEncoderV2;
contract DfyAdvisorLocker is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
// DFY TOKEN
IERC20 public dfy;
// Total DFY amount
uint256 public totalDFY;
// Distribution starting timestamp
uint256 public startTimestamp;
// Distribution ending timestamp
uint256 public endTimestamp;
// Info of each user.
struct UserInfo {
uint256 amount; // amount of DFY.
uint256 debt; // previously claimed DFY amount.
uint256 lastDristibution; // timestamp of last distribution to the user
bool inList; // user status
}
// Used for adding users to the list
struct addUser {
address userAddress;
uint256 amount; // amount of DFY.
}
mapping (address => UserInfo) public userList;
address[] public userAddrList;
// Dev address.
address public auto_sender;
// emergency dev
address emDev;
modifier onlyDev() {
require(msg.sender == owner() || msg.sender == auto_sender , "Error: Require developer or Owner");
_;
}
event DistributeDFY();
event Claim(address User, uint256 amount);
event RenounceEmDev();
constructor(IERC20 _dfy,
address _autosender,
uint256 _startTimestamp)
public {
dfy = _dfy;
auto_sender = _autosender;
startTimestamp = _startTimestamp;
endTimestamp = _startTimestamp.add(365 days);
totalDFY = 0;
emDev = msg.sender;
}
receive() external payable {
revert();
}
function listSize() external view returns (uint256) {
return userAddrList.length;
}
function renounceEmDev() external {
require (msg.sender == emDev , "only emergency dev");
emDev = address(0);
emit RenounceEmDev();
}
// Add user data to the userlist. Can only be called by the dev or owner.
function addUsers(addUser[] calldata holders) external onlyDev returns(bool){
uint256 length = holders.length;
for (uint i = 0; i < length; i++) {
address _user = holders[i].userAddress;
uint256 _amount = holders[i].amount;
UserInfo storage user = userList[_user];
require(!user.inList , "user already added");
userAddrList.push(_user);
user.amount = _amount;
user.debt = 0;
user.lastDristibution = startTimestamp;
user.inList = true;
totalDFY = totalDFY.add(_amount);
}
return(true);
}
function editUserAmount(address _user , uint256 _amount) external onlyDev returns(bool){
UserInfo storage user = userList[_user];
require(user.inList , "user not added!");
user.debt = 0;
totalDFY = totalDFY.sub(user.amount);
user.amount = _amount;
totalDFY = totalDFY.add(_amount);
user.debt = pendingDfy(_user);
return(true);
}
function pendingDfy(address _user) public view returns (uint256) {
UserInfo storage user = userList[_user];
uint256 multiplier = 0;
if (block.timestamp > user.lastDristibution && totalDFY != 0 && user.inList) {
uint256 blockTimestamp = block.timestamp < endTimestamp ? block.timestamp : endTimestamp;
multiplier = (blockTimestamp.sub(startTimestamp));
return user.amount.mul(multiplier).div(365 days).sub(user.debt);
}
else {
return (0);
}
}
// Distribute tokens.
function distributeDFY() external onlyDev returns(bool){
require(dfy.balanceOf(address(this)) > 0 ,'Nothing to distribute');
require(startTimestamp < block.timestamp , "distribution not started");
for (uint i = 0 ; i < userAddrList.length ; i++)
{
address addr = userAddrList[i];
uint256 pending = pendingDfy(addr);
if (pending > 0){
safeDefyTransfer(addr, pending);
UserInfo storage user = userList[addr];
user.debt = user.debt.add(pending);
user.lastDristibution = block.timestamp;
}
}
emit DistributeDFY();
return(true);
}
//claim pending
function claimPending() external returns(bool){
require (userList[msg.sender].inList , "Error : Unknown user ");
uint256 pending = pendingDfy(msg.sender);
require (pending > 0 , 'Nothing to claim');
require(dfy.balanceOf(address(this)) > 0 ,'Nothing to distribute');
require(startTimestamp < block.timestamp , "distribution not started");
safeDefyTransfer(msg.sender, pending);
UserInfo storage user = userList[msg.sender];
user.debt = user.debt.add(pending);
user.lastDristibution = block.timestamp;
emit Claim(msg.sender, pending);
return(true);
}
function safeDefyTransfer(address _to, uint256 _amount) internal {
uint256 dfyBal = dfy.balanceOf(address(this));
bool successfulTansfer = false;
if (_amount > dfyBal) {
successfulTansfer = dfy.transfer(_to, dfyBal);
} else {
successfulTansfer = dfy.transfer(_to, _amount);
}
require(successfulTansfer, "safeDefyTransfer: transfer failed");
}
function withdrawRemainder(address receiver)external onlyOwner {
require(block.timestamp > endTimestamp.add(30 days) , "only withdrawable after 30 days from distribution period end");
safeDefyTransfer(receiver, dfy.balanceOf(address(this)));
}
function emergencyWithdraw() external {
require (msg.sender == emDev , "only emergency dev");
safeDefyTransfer(msg.sender, dfy.balanceOf(address(this)));
}
function setAutosender(address _autoSender)external onlyDev
{
auto_sender = _autoSender;
return;
}
}
| 321,110 | 12,912 |
2af545db79c2721e429c0cd8cad46bcb0870b05514ceaa5aff2886d9b4647f47
| 12,253 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0x3365539eff879eebf7f3369f65288d3f8d3cb40e_nonpublicVarAccessdByPublicFunc.sol
| 2,589 | 12,138 |
pragma solidity ^0.5.12;
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b); // the same as: if (a !=0 && c / a != b) {throw;}
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// Ownable Contract
// ----------------------------------------------------------------------------
contract Ownable {
address internal owner;
address internal master;
event MasterOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event SetOwner(address indexed previousOwner, address indexed newOwner);
// The Ownable constructor sets the original `owner` of the contract to the sender account
constructor() public {
owner = msg.sender;
master = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner||msg.sender == master);
_;
}
function setOwnership(address newOwner) public {
require(msg.sender == master); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(newOwner != address(0));
emit SetOwner(owner, newOwner); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
owner = newOwner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function transferMasterOwnership(address newOwner) public {
require(msg.sender == master); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(newOwner != address(0));
emit MasterOwnershipTransferred(owner, newOwner); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
master = newOwner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
// ----------------------------------------------------------------------------
// Pausable Contract
// ----------------------------------------------------------------------------
contract Pausable is Ownable {
event Pause();
event Unpause();
bool internal paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
//pause transfer when emergency
function pause() onlyOwner whenNotPaused public {
paused = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Unpause();
}
}
// ----------------------------------------------------------------------------
// BlackList Contract
// ----------------------------------------------------------------------------
contract BlackList is Ownable {
event AddedBlackList(address indexed _user);
event RemovedBlackList(address indexed _user);
mapping (address => bool) internal isBlackListed;
function getBlackListStatus(address _addr) public view returns (bool) {
return isBlackListed[_addr]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function addBlackList (address _addr) public onlyOwner {
isBlackListed[_addr] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit AddedBlackList(_addr);
}
function removeBlackList (address _addr) public onlyOwner {
isBlackListed[_addr] = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit RemovedBlackList(_addr);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract USDRToken is ERC20Interface, Pausable, BlackList {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event IncrementSupply(address indexed owner, uint256 increments);
event BurnTokens(address indexed owner, uint256 amount);
event BrunBlackTokens(address indexed blackListedUser, uint256 amount);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
symbol = "USDR";
name = "USD Receipt";
decimals = 18;
_totalSupply = 5460000 * 10**uint(decimals);
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// ------------------------------------------------------------------------
// 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 whenNotPaused returns (bool success) {
require(!isBlackListed[msg.sender],"blocked address"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(to != address(0), "to address is a zero address");
balances[msg.sender] = balances[msg.sender].sub(tokens); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
balances[to] = balances[to].add(tokens); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
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) {
require(spender != address(0), "spender address is a zero address");
allowed[msg.sender][spender] = tokens; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
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 whenNotPaused returns (bool success) {
require(!isBlackListed[from],"blocked address"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(to != address(0), "to address is a zero address");
balances[from] = balances[from].sub(tokens); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
balances[to] = balances[to].add(tokens); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// ------------------------------------------------------------------------
// Increment supply
// ------------------------------------------------------------------------
function incrementSupply(uint256 increments) public onlyOwner returns (bool){
require(increments > 0);
uint256 curTotalSupply = _totalSupply; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 previousBalance = balanceOf(msg.sender);
_totalSupply = curTotalSupply.add(increments); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
balances[msg.sender] = previousBalance.add(increments); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit IncrementSupply(msg.sender, increments);
emit Transfer(address(0), msg.sender, increments);
return true;
}
// ------------------------------------------------------------------------
// Burns `amount` tokens from `owner`
// @param amount The quantity of tokens being burned
// @return True if the tokens are burned correctly
// ------------------------------------------------------------------------
function burnTokens(uint256 amount) public onlyOwner returns (bool) {
require(amount > 0);
uint256 curTotalSupply = _totalSupply; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(curTotalSupply >= amount);
uint256 previousBalanceTo = balanceOf(msg.sender);
require(previousBalanceTo >= amount);
_totalSupply = curTotalSupply.sub(amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
balances[msg.sender] = previousBalanceTo.sub(amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit BurnTokens(msg.sender, amount);
emit Transfer(msg.sender, address(0), amount);
return true;
}
function brunBlackTokens (address blackListedUser) public onlyOwner returns (bool) {
require(isBlackListed[blackListedUser]); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 dirtyFunds = balanceOf(blackListedUser);
require(dirtyFunds > 0);
uint256 curTotalSupply = _totalSupply; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(curTotalSupply >= dirtyFunds);
balances[blackListedUser] = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_totalSupply = curTotalSupply.sub(dirtyFunds); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit BurnTokens(blackListedUser, dirtyFunds);
emit Transfer(blackListedUser, address(0), dirtyFunds);
emit BrunBlackTokens(blackListedUser, dirtyFunds);
return true;
}
}
| 279,848 | 12,913 |
4d414d3f024a1ed032bb7ec6bbf9ba0e0d64f935c04bac1ad8ff828f1e56831e
| 26,974 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Decentralized Exchange/Normal/klimadao/contracts/staking/regular/KlimaStakingDistributor.sol
| 3,908 | 15,070 |
//
//
//
//
//
//
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
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");
}
// require(address(this).balance >= value, "Address: insufficient balance for call");
// return _functionCallWithValue(target, data, value, errorMessage);
// }
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IVault {
function depositReserves(uint amount_) external returns (bool);
}
interface IStaking {
function stakeKLIMA(uint amountToStake_) external returns (bool);
}
contract KlimaStakingDistributor {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public owner;
address public vault;
address public KLIMA;
address public VCU20;
address public DAO;
address public stakingContract;
uint public nextEpochBlock;
uint public blocksInEpoch;
// reward rate is in hundreths i.e. 50 = 0.5%
uint public rewardRate;
bool public isInitialized;
constructor() {
owner = msg.sender;
}
function initialize(uint _nextEpochBlock, uint _blocksInEpoch, uint _rewardRate, address _vault, address _stakingContract, address _KLIMA, address _VCU20, address _DAO) external returns (bool) {
require(msg.sender == owner);
require(isInitialized == false);
nextEpochBlock = _nextEpochBlock;
blocksInEpoch = _blocksInEpoch;
rewardRate = _rewardRate;
vault = _vault;
stakingContract = _stakingContract;
KLIMA = _KLIMA;
VCU20 = _VCU20;
DAO = _DAO;
isInitialized = true;
return true;
}
function distribute() external returns (bool) {
if (block.number >= nextEpochBlock) {
nextEpochBlock = nextEpochBlock.add(blocksInEpoch);
uint _klimaToDistribute = IERC20(KLIMA).totalSupply().mul(rewardRate).div(10000);
IERC20(KLIMA).safeTransfer(stakingContract, _klimaToDistribute);
IStaking(stakingContract).stakeKLIMA(0);
}
return true;
}
function convertVCU20ToKLIMA(uint _amountToConvert) external returns (bool) {
require(msg.sender == owner);
IERC20(VCU20).approve(vault, _amountToConvert);
IVault(vault).depositReserves(_amountToConvert);
return true;
}
function setBlocksInEpoch(uint _blocksInEpoch) external returns (bool) {
require(msg.sender == owner);
blocksInEpoch = _blocksInEpoch;
return true;
}
// reward rate is in hundreths i.e. 50 = 0.5%
function setRewardRate(uint _rewardRate) external returns (bool) {
require(msg.sender == owner);
rewardRate = _rewardRate;
return true;
}
function setVault(address _vault) external returns (bool) {
require(msg.sender == owner);
vault = _vault;
return true;
}
function setStaking(address _staking) external returns (bool) {
require(msg.sender == owner);
stakingContract = _staking;
return true;
}
function transferOwnership(address _owner) external returns (bool) {
require(msg.sender == owner);
owner = _owner;
return true;
}
function transferVCU20ToDAO() external returns (bool) {
require(msg.sender == owner);
IERC20(VCU20).safeTransfer(DAO, IERC20(VCU20).balanceOf(address(this)));
return true;
}
function transferKLIMAToDAO() external returns (bool) {
require(msg.sender == owner);
IERC20(KLIMA).safeTransfer(DAO, IERC20(KLIMA).balanceOf(address(this)));
return true;
}
function getCurrentRewardForNextEpoch() external view returns (uint) {
return IERC20(KLIMA).totalSupply().mul(rewardRate).div(10000);
}
}
| 70,003 | 12,914 |
62f12e6004e5a5a30f729bed51f202982347911f0e6202eb68e4dfac2d25c2de
| 26,071 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x50F953C75847F6869da66f2d05DA018706Ea2a46_affectedByMiners.sol
| 4,073 | 15,998 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
// 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 (block.number > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IController {
function withdraw(address, uint256) external;
function balanceOf(address) external view returns (uint256);
function earn(address, uint256) external;
function want(address) external view returns (address);
function rewards() external view returns (address);
function vaults(address) external view returns (address);
}
//
interface Uni {
function swapExactTokensForTokens(uint256,
uint256,
address[] calldata,
address,
uint256) external;
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
}
//
interface IUniPair {
function token0() external view returns (address);
function token1() external view returns (address);
}
//
interface IUniStakingRewards {
function balanceOf(address account) external view returns (uint256);
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
//
contract UniStrategyLP {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public immutable want;
address public immutable weth;
address public immutable underlyingToken;
address public immutable rewardUni;
address public immutable uniRouter;
address public immutable uniStakingPool;
address[] public pathUnderlying;
address[] public pathWeth;
string private name;
uint256 public performanceFee = 500;
uint256 public immutable performanceMax = 10000;
uint256 public withdrawalFee = 0;
uint256 public immutable withdrawalMax = 10000;
address public governance;
address public controller;
address public timelock;
constructor
(address _controller,
string memory _name,
address _want,
address _rewardUni,
address _uniRouter,
address _uniStakingPool,
address[] memory _pathWeth,
address[] memory _pathUnderlying,
address _timelock)
public
{
governance = msg.sender;
controller = _controller;
name = _name;
want = _want;
weth = IUniPair(_want).token0();
underlyingToken = IUniPair(_want).token1();
rewardUni = _rewardUni;
uniRouter = _uniRouter;
uniStakingPool = _uniStakingPool;
pathWeth = _pathWeth;
pathUnderlying = _pathUnderlying;
timelock = _timelock;
}
function getName() external view returns (string memory) {
return name;
}
function setWithdrawalFee(uint256 _withdrawalFee) external {
require(msg.sender == governance, "!governance");
require(_withdrawalFee < withdrawalMax, "inappropriate withdraw fee");
withdrawalFee = _withdrawalFee;
}
function setPerformanceFee(uint256 _performanceFee) external {
require(msg.sender == governance, "!governance");
require(_performanceFee < performanceMax, "inappropriate performance fee");
performanceFee = _performanceFee;
}
function SetPathWeth(address[] memory _path) external {
require(msg.sender == governance, "!governance");
pathWeth = _path;
}
function SetPathUnderlying(address[] memory _path) external {
require(msg.sender == governance, "!governance");
pathUnderlying = _path;
}
function deposit() public {
uint256 wantAmount = IERC20(want).balanceOf(address(this));
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(want).safeApprove(uniStakingPool, 0);
IERC20(want).safeApprove(uniStakingPool, wantAmount);
IUniStakingRewards(uniStakingPool).stake(wantAmount);
}
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
IUniStakingRewards(uniStakingPool).exit();
balance = IERC20(want).balanceOf(address(this));
uint256 rewarAmount = IERC20(rewardUni).balanceOf(address(this));
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, balance);
if(block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(rewardUni).safeTransfer(_vault, rewarAmount);
}
}
function withdraw(uint256 _amount) external {
require(msg.sender == controller, "!controller");
uint256 _balance = IERC20(want).balanceOf(address(this));
if (block.gaslimit < _amount) { //injected CONTRACT AFFECTED BY MINERS
IUniStakingRewards(uniStakingPool).withdraw(_amount.sub(_balance));
_amount = IERC20(want).balanceOf(address(this));
}
uint256 _fee = _amount.mul(withdrawalFee).div(withdrawalMax);
IERC20(want).safeTransfer(IController(controller).rewards(), _fee);
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, _amount.sub(_fee));
}
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
require(want != address(_asset), "want");
require(rewardUni != address(_asset), "rewardUni");
require(underlyingToken != address(_asset), "underlyingToken");
require(weth != address(_asset), "weth");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(controller, balance);
}
function harvest() public {
IUniStakingRewards(uniStakingPool).getReward();
uint256 _rewardUni = IERC20(rewardUni).balanceOf(address(this));
if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
IERC20(rewardUni).safeApprove(uniRouter, 0);
IERC20(rewardUni).safeApprove(uniRouter, _rewardUni);
Uni(uniRouter).swapExactTokensForTokens(_rewardUni, 1, pathWeth, address(this), now);
uint256 wethAmount = IERC20(weth).balanceOf(address(this));
IERC20(weth).safeApprove(uniRouter, 0);
IERC20(weth).safeApprove(uniRouter, wethAmount);
wethAmount = wethAmount.div(2);
Uni(uniRouter).swapExactTokensForTokens(wethAmount, 1, pathUnderlying, address(this), now);
uint256 underlyingTokenAmount = IERC20(underlyingToken).balanceOf(address(this));
IERC20(underlyingToken).safeApprove(uniRouter, 0);
IERC20(underlyingToken).safeApprove(uniRouter, underlyingTokenAmount);
Uni(uniRouter).addLiquidity(weth,
underlyingToken,
wethAmount,
underlyingTokenAmount,
1, // we are willing to take whatever the pair gives us
1,
address(this),
now);
}
uint256 harvestAmount = IERC20(want).balanceOf(address(this));
if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS
uint256 _fee = harvestAmount.mul(performanceFee).div(performanceMax);
IERC20(want).safeTransfer(IController(controller).rewards(), _fee);
deposit();
}
}
function balanceOfWant() public view returns (uint256) {
return IERC20(want).balanceOf(address(this));
}
function balanceOfPool() public view returns (uint256) {
return IUniStakingRewards(uniStakingPool).balanceOf(address(this));
}
function balanceOf() public view returns (uint256) {
return balanceOfWant().add(balanceOfPool());
}
function setGovernance(address _governance) external {
require(msg.sender == timelock, "!timelock");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == timelock, "!timelock");
controller = _controller;
}
function setTimelock(address _timelock) public {
require(msg.sender == timelock, "!timelock");
timelock = _timelock;
}
}
| 281,003 | 12,915 |
81257bc0e3b687e60fa478fb7371dfaf00af54464b22750607fd2f75508330b0
| 18,277 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d3/d3746D6249bB3B4D0ABC69F03dcF82ab6B1Ca6A6_BondPriceHelper.sol
| 3,016 | 12,313 |
// 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 BondPriceHelper 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 addBondContracts(address[] memory _contracts) external onlyManager {
for(uint i=0;i<_contracts.length;i++) {
addBond(_contracts[i]);
}
}
function addBond(address bond) internal 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();
}
}
| 122,289 | 12,916 |
18da85007d8fdad91e4b1fb24d53921b9b158246ef416e64c5d179574537fb80
| 18,562 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/fe/FEAF9e0A57e626f72E1a5fff507D7A2d9A9F0EE9_PerpsV2MarketState.sol
| 2,892 | 12,940 |
pragma solidity ^0.5.16;
interface IPerpsV2MarketBaseTypes {
enum OrderType {Atomic, Delayed, Offchain}
enum Status {
Ok,
InvalidPrice,
InvalidOrderType,
PriceOutOfBounds,
CanLiquidate,
CannotLiquidate,
MaxMarketSizeExceeded,
MaxLeverageExceeded,
InsufficientMargin,
NotPermitted,
NilOrder,
NoPositionOpen,
PriceTooVolatile,
PriceImpactToleranceExceeded
}
// If margin/size are positive, the position is long; if negative then it is short.
struct Position {
uint64 id;
uint64 lastFundingIndex;
uint128 margin;
uint128 lastPrice;
int128 size;
}
// Delayed order storage
struct DelayedOrder {
bool isOffchain; // flag indicating the delayed order is offchain
int128 sizeDelta; // difference in position to pass to modifyPosition
uint128 priceImpactDelta; // price impact tolerance as a percentage used on fillPrice at execution
uint128 targetRoundId; // price oracle roundId using which price this order needs to executed
uint128 commitDeposit; // the commitDeposit paid upon submitting that needs to be refunded if order succeeds
uint128 keeperDeposit; // the keeperDeposit paid upon submitting that needs to be paid / refunded on tx confirmation
uint256 executableAtTime; // The timestamp at which this order is executable at
uint256 intentionTime; // The block timestamp of submission
bytes32 trackingCode; // tracking code to emit on execution for volume source fee sharing
}
}
// https://docs.synthetix.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// https://docs.synthetix.io/contracts/source/libraries/addresssetlib/
library AddressSetLib {
struct AddressSet {
address[] elements;
mapping(address => uint) indices;
}
function contains(AddressSet storage set, address candidate) internal view returns (bool) {
if (set.elements.length == 0) {
return false;
}
uint index = set.indices[candidate];
return index != 0 || set.elements[0] == candidate;
}
function getPage(AddressSet storage set,
uint index,
uint pageSize) internal view returns (address[] memory) {
uint endIndex = index + pageSize; // The check below that endIndex <= index handles overflow.
// If the page extends past the end of the list, truncate it.
if (endIndex > set.elements.length) {
endIndex = set.elements.length;
}
if (endIndex <= index) {
return new address[](0);
}
uint n = endIndex - index; // We already checked for negative overflow.
address[] memory page = new address[](n);
for (uint i; i < n; i++) {
page[i] = set.elements[i + index];
}
return page;
}
function add(AddressSet storage set, address element) internal {
// Adding to a set is an idempotent operation.
if (!contains(set, element)) {
set.indices[element] = set.elements.length;
set.elements.push(element);
}
}
function remove(AddressSet storage set, address element) internal {
require(contains(set, element), "Element not in set.");
// Replace the removed element with the last element of the list.
uint index = set.indices[element];
uint lastIndex = set.elements.length - 1; // We required that element is in the list, so it is not empty.
if (index != lastIndex) {
// No need to shift the last element if it is the one we want to delete.
address shiftedElement = set.elements[lastIndex];
set.elements[index] = shiftedElement;
set.indices[shiftedElement] = index;
}
set.elements.pop();
delete set.indices[element];
}
}
// Inheritance
// Libraries
// https://docs.synthetix.io/contracts/source/contracts/StateShared
contract StateShared is Owned {
using AddressSetLib for AddressSetLib.AddressSet;
// the address of the contract that can modify variables
// this can only be changed by the owner of this contract
AddressSetLib.AddressSet internal _associatedContracts;
constructor(address[] memory associatedContracts) internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
_addAssociatedContracts(associatedContracts);
}
function _addAssociatedContracts(address[] memory associatedContracts) internal {
for (uint i = 0; i < associatedContracts.length; i++) {
if (!_associatedContracts.contains(associatedContracts[i])) {
_associatedContracts.add(associatedContracts[i]);
emit AssociatedContractAdded(associatedContracts[i]);
}
}
}
// Add associated contracts
function addAssociatedContracts(address[] calldata associatedContracts) external onlyOwner {
_addAssociatedContracts(associatedContracts);
}
// Remove associated contracts
function removeAssociatedContracts(address[] calldata associatedContracts) external onlyOwner {
for (uint i = 0; i < associatedContracts.length; i++) {
if (_associatedContracts.contains(associatedContracts[i])) {
_associatedContracts.remove(associatedContracts[i]);
emit AssociatedContractRemoved(associatedContracts[i]);
}
}
}
function associatedContracts() external view returns (address[] memory) {
return _associatedContracts.getPage(0, _associatedContracts.elements.length);
}
modifier onlyAssociatedContracts {
require(_associatedContracts.contains(msg.sender), "Only an associated contract can perform this action");
_;
}
event AssociatedContractAdded(address associatedContract);
event AssociatedContractRemoved(address associatedContract);
}
pragma experimental ABIEncoderV2;
// Inheritance
// Libraries
// https://docs.synthetix.io/contracts/source/contracts/PerpsV2MarketState
contract PerpsV2MarketState is Owned, StateShared, IPerpsV2MarketBaseTypes {
using AddressSetLib for AddressSetLib.AddressSet;
// The market identifier in the perpsV2 system (manager + settings). Multiple markets can co-exist
// for the same asset in order to allow migrations.
bytes32 public marketKey;
// The asset being traded in this market. This should be a valid key into the ExchangeRates contract.
bytes32 public baseAsset;
// The total number of base units in long and short positions.
uint128 public marketSize;
int128 public marketSkew;
int128 internal _entryDebtCorrection;
uint32 public fundingLastRecomputed;
int128[] public fundingSequence;
int128 public fundingRateLastRecomputed;
mapping(address => Position) public positions;
// The set of all addresses (positions) .
AddressSetLib.AddressSet internal _positionAddresses;
// The set of all addresses (delayedOrders) .
AddressSetLib.AddressSet internal _delayedOrderAddresses;
// This increments for each position; zero reflects a position that does not exist.
uint64 internal _nextPositionId = 1;
/// @dev Holds a mapping of accounts to orders. Only one order per account is supported
mapping(address => DelayedOrder) public delayedOrders;
constructor(address _owner,
address[] memory _associatedContracts,
bytes32 _baseAsset,
bytes32 _marketKey) public Owned(_owner) StateShared(_associatedContracts) {
baseAsset = _baseAsset;
marketKey = _marketKey;
fundingSequence.push(0);
fundingRateLastRecomputed = 0;
}
function entryDebtCorrection() external view returns (int128) {
return _entryDebtCorrection;
}
function nextPositionId() external view returns (uint64) {
return _nextPositionId;
}
function fundingSequenceLength() external view returns (uint) {
return fundingSequence.length;
}
function getPositionAddressesPage(uint index, uint pageSize)
external
view
onlyAssociatedContracts
returns (address[] memory)
{
return _positionAddresses.getPage(index, pageSize);
}
function getDelayedOrderAddressesPage(uint index, uint pageSize)
external
view
onlyAssociatedContracts
returns (address[] memory)
{
return _delayedOrderAddresses.getPage(index, pageSize);
}
function getPositionAddressesLength() external view onlyAssociatedContracts returns (uint) {
return _positionAddresses.elements.length;
}
function getDelayedOrderAddressesLength() external view onlyAssociatedContracts returns (uint) {
return _delayedOrderAddresses.elements.length;
}
function setMarketKey(bytes32 _marketKey) external onlyAssociatedContracts {
require(marketKey == bytes32(0) || _marketKey == marketKey, "Cannot change market key");
marketKey = _marketKey;
}
function setBaseAsset(bytes32 _baseAsset) external onlyAssociatedContracts {
require(baseAsset == bytes32(0) || _baseAsset == baseAsset, "Cannot change base asset");
baseAsset = _baseAsset;
}
function setMarketSize(uint128 _marketSize) external onlyAssociatedContracts {
marketSize = _marketSize;
}
function setEntryDebtCorrection(int128 entryDebtCorrection) external onlyAssociatedContracts {
_entryDebtCorrection = entryDebtCorrection;
}
function setNextPositionId(uint64 nextPositionId) external onlyAssociatedContracts {
_nextPositionId = nextPositionId;
}
function setMarketSkew(int128 _marketSkew) external onlyAssociatedContracts {
marketSkew = _marketSkew;
}
function setFundingLastRecomputed(uint32 lastRecomputed) external onlyAssociatedContracts {
fundingLastRecomputed = lastRecomputed;
}
function pushFundingSequence(int128 _fundingSequence) external onlyAssociatedContracts {
fundingSequence.push(_fundingSequence);
}
// TODO: Perform this update when maxFundingVelocity and skewScale are modified.
function setFundingRateLastRecomputed(int128 _fundingRateLastRecomputed) external onlyAssociatedContracts {
fundingRateLastRecomputed = _fundingRateLastRecomputed;
}
function updatePosition(address account,
uint64 id,
uint64 lastFundingIndex,
uint128 margin,
uint128 lastPrice,
int128 size) external onlyAssociatedContracts {
positions[account] = Position(id, lastFundingIndex, margin, lastPrice, size);
_positionAddresses.add(account);
}
function updateDelayedOrder(address account,
bool isOffchain,
int128 sizeDelta,
uint128 priceImpactDelta,
uint128 targetRoundId,
uint128 commitDeposit,
uint128 keeperDeposit,
uint256 executableAtTime,
uint256 intentionTime,
bytes32 trackingCode) external onlyAssociatedContracts {
delayedOrders[account] = DelayedOrder(isOffchain,
sizeDelta,
priceImpactDelta,
targetRoundId,
commitDeposit,
keeperDeposit,
executableAtTime,
intentionTime,
trackingCode);
_delayedOrderAddresses.add(account);
}
function deletePosition(address account) external onlyAssociatedContracts {
delete positions[account];
if (_positionAddresses.contains(account)) {
_positionAddresses.remove(account);
}
}
function deleteDelayedOrder(address account) external onlyAssociatedContracts {
delete delayedOrders[account];
if (_delayedOrderAddresses.contains(account)) {
_delayedOrderAddresses.remove(account);
}
}
}
| 151,929 | 12,917 |
eb2de81375f0bf1e634664722b58515584562a86b70bc3218f15cd78d8804432
| 22,444 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x38d3d9abbdba8305ebb8b72996efe55bf785aed0.sol
| 3,227 | 12,971 |
pragma solidity 0.4.23;
contract EToken2Interface {
function baseUnit(bytes32 _symbol) constant returns(uint8);
function name(bytes32 _symbol) constant returns(string);
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 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) public returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performApprove(address _spender, uint _value, address _sender) public returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performGeneric(bytes, address) public 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() public view returns(uint256 supply);
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);
// function symbol() constant returns(string);
function decimals() public view returns(uint8);
// function name() constant returns(string);
}
contract AssetProxyInterface is ERC20Interface {
function _forwardApprove(address _spender, uint _value, address _sender) public returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public returns(bool);
function etoken2() public pure returns(address) {} // To be replaced by the implicit getter;
function etoken2Symbol() public pure returns(bytes32) {} // To be replaced by the implicit getter;
}
contract Bytes32 {
function _bytes32(string _input) internal pure returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal pure {
assembly {
let returndatastart := 0
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(gas, _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract UnicornSPXSecurityToken is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) public 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 view returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public onlyAssetOwner() returns(bool) {
return _asset.transfer(_receiver, _value);
}
function totalSupply() public view returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) public view returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) public view returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() public view returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) public returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) public returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) public returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) public onlyEToken2() {
emit Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) public onlyEToken2() {
emit Approval(_from, _spender, _value);
}
function () public payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
// Interface functions to allow specifying ICAP addresses as strings.
function transferToICAP(string _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) public returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) public 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);
// Current asset implementation contract address.
address internal latestVersion;
// Proposed next asset implementation contract address.
address internal pendingVersion;
// Upgrade freeze-time start.
uint internal pendingVersionTimestamp;
// Timespan for users to review the new implementation and make decision.
uint constant UPGRADE_FREEZE_TIME = 3 days;
// Asset implementation contract address that user decided to stick with.
// 0x0 means that user uses latest version.
mapping(address => address) internal userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) public view returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() public view returns(address) {
return latestVersion;
}
function getPendingVersion() public view returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() public view returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) public onlyAssetOwner() returns(bool) {
// Should not already be in the upgrading process.
if (pendingVersion != 0x0) {
return false;
}
// New version address should be other than 0x0.
if (_newVersion == 0x0) {
return false;
}
// Don't apply freeze-time for the initial setup.
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
emit UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() public onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
emit UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() public returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
emit UpgradeCommited(latestVersion);
return true;
}
function optOut() public returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
emit OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() public returns(bool) {
delete userOptOutVersion[msg.sender];
emit OptedIn(msg.sender, latestVersion);
return true;
}
// Backwards compatibility.
function multiAsset() public view returns(EToken2Interface) {
return etoken2;
}
}
| 203,228 | 12,918 |
92a17abb53f8529f423476427f2f6c25a0d9bd4a020895ebff6b50ffa0acb426
| 10,524 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe15422570cb3cd88bd7ef87f14c6ca7c43f77398.sol
| 2,764 | 9,382 |
pragma solidity ^0.4.13;
// Interface to ZBR ICO Contract
contract DaoToken {
uint256 public CAP;
uint256 public totalEthers;
function proxyPayment(address participant) payable;
function transfer(address _to, uint _amount) returns (bool success);
}
contract ZiberToken {
// Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
// Store whether or not each account would have made it into the crowdsale.
mapping (address => bool) public checked_in;
// Bounty for executing buy.
uint256 public bounty;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens;
// Record the time the contract bought the tokens.
uint256 public time_bought;
// Emergency kill switch in case a critical bug is found.
bool public kill_switch;
string public name;
string public symbol;
uint8 public decimals;
// Ratio of ZBR tokens received to ETH contributed
// 1.000.000 BGP = 80.000.000 ZBR
// 1ETH = 218 BGP (03.07.2017: https://www.coingecko.com/en/price_charts/ethereum/gbp)
// 1 ETH = 17440 ZBR
uint256 ZBR_per_eth = 17440;
//Total ZBR Tokens Reserve
uint256 ZBR_total_reserve = 100000000;
// ZBR Tokens for Developers
uint256 ZBR_dev_reserved = 10000000;
// ZBR Tokens for Selling over ICO
uint256 ZBR_for_selling = 80000000;
// ZBR Tokens for Bounty
uint256 ZBR_for_bounty= 10000000;
// ETH for activate kill-switch in contract
uint256 ETH_to_end = 50000 ether;
uint registredTo;
uint256 loadedRefund;
uint256 _supply;
string _name;
string _symbol;
uint8 _decimals;
// The ZBR Token address and sale address are the same.
DaoToken public token = DaoToken(0xa9d585CE3B227d69985c3F7A866fE7d0e510da50);
// The developer address.
address developer_address = 0x650887B33BFA423240ED7Bc4BD26c66075E3bEaf;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
function ZiberToken() {
_supply = 10000000000;
balanceOf[msg.sender] = _supply;
name = "ZIBER CW Tokens";
symbol = "ZBR";
decimals = 2;
}
/// SafeMath contract - math operations with safety checks
/// @author dev@smartcontracteam.com
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
function loadRefund() payable {
if(msg.value == 0) throw;
loadedRefund = safeAdd(loadedRefund, msg.value);
}
function refund() private {
uint256 weiValue = this.balance;
if (weiValue == 0) throw;
uint256 weiRefunded;
weiRefunded = safeAdd(weiRefunded, weiValue);
refund();
if (!msg.sender.send(weiValue)) throw;
}
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
// Allows the developer to shut down everything except withdrawals in emergencies.
function activate_kill_switch() {
// Only allow the developer to activate the kill switch.
if (msg.sender != developer_address) throw;
// Irreversibly activate the kill switch.
kill_switch = true;
}
// Withdraws all ETH deposited or ZBR purchased by the sender.
function withdraw(){
// If called before the ICO, cancel caller's participation in the sale.
if (!bought_tokens) {
// Store the user's balance prior to withdrawal in a temporary variable.
uint256 eth_amount = balances[msg.sender];
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_amount);
}
// Withdraw the sender's tokens if the contract has already purchased them.
else {
// Store the user's ZBR balance in a temporary variable (1 ETHWei -> 2000 ZBRWei).
uint256 ZBR_amount = balances[msg.sender] * ZBR_per_eth;
// Update the user's balance prior to sending ZBR to prevent recursive call.
balances[msg.sender] = 0;
// No fee for withdrawing if the user would have made it into the crowdsale alone.
uint256 fee = 0;
// 1% fee if the user didn't check in during the crowdsale.
if (!checked_in[msg.sender]) {
fee = ZBR_amount / 100;
// Send any non-zero fees to developer.
if(!token.transfer(developer_address, fee)) throw;
}
// Send the user their tokens. Throws if the crowdsale isn't over.
if(!token.transfer(msg.sender, ZBR_amount - fee)) throw;
}
}
// Allow developer to add ETH to the buy execution bounty.
function add_to_bounty() payable {
// Only allow the developer to contribute to the buy execution bounty.
if (msg.sender != developer_address) throw;
// Disallow adding to bounty if kill switch is active.
if (kill_switch) throw;
// Disallow adding to the bounty if contract has already bought the tokens.
if (bought_tokens) throw;
// Update bounty to include received amount.
bounty += msg.value;
}
// Buys tokens in the crowdsale and rewards the caller, callable by anyone.
function claim_bounty(){
// Short circuit to save gas if the contract has already bought tokens.
if (bought_tokens) return;
// Disallow buying into the crowdsale if kill switch is active.
if (kill_switch) throw;
// Record that the contract has bought the tokens.
bought_tokens = true;
// Record the time the contract bought the tokens.
time_bought = now + 1 days;
// Transfer all the funds (less the bounty) to the ZBR crowdsale contract
// to buy tokens. Throws if the crowdsale hasn't started yet or has
// already completed, preventing loss of funds.
token.proxyPayment.value(this.balance - bounty)(address(this));
// Send the caller their bounty for buying tokens for the contract.
if(this.balance > ETH_to_end)
{
msg.sender.transfer(bounty);
}
else {
time_bought = now + 1 days * 9;
if(this.balance > ETH_to_end) {
msg.sender.transfer(bounty);
}
}
}
//Check is msg_sender is contract dev
modifier onlyOwner() {
if (msg.sender != developer_address) {
throw;
}
_;
}
// Send fund when ico end
function withdrawEth() onlyOwner {
msg.sender.transfer(this.balance);
}
//Kill contract
function kill() onlyOwner {
selfdestruct(developer_address);
}
// A helper function for the default function, allowing contracts to interact.
function default_helper() payable {
// Check if ICO Started: 27.07.2017 12:00 GMT to get ETH //1501156800
if (now < 1500400350) throw;
else {
// Treat near-zero ETH transactions as check ins and withdrawal requests.
if (msg.value <= 1 finney) {
// Check in during the crowdsale.
if (bought_tokens) {
// Only allow checking in before the crowdsale has reached the cap.
if (token.totalEthers() >= token.CAP()) throw;
// Mark user as checked in, meaning they would have been able to enter alone.
checked_in[msg.sender] = true;
}
// Withdraw funds if the crowdsale hasn't begun yet or is already over.
else {
withdraw();
}
}
// Deposit the user's funds for use in purchasing tokens.
else {
// Disallow deposits if kill switch is active.
if (kill_switch) throw;
// Only allow deposits if the contract hasn't already purchased the tokens.
if (bought_tokens) throw;
// Update records of deposited ETH to include the received amount.
balances[msg.sender] += msg.value;
}
}
}
// Default function. Called when a user sends ETH to the contract.
function () payable {
// Delegate to the helper function.
default_helper();
}
function transferCheck() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 187,325 | 12,919 |
da341459b9c2398c0f53006ef9f91ccb0e28a93e3d0065267785b634e8c2d62b
| 26,513 |
.sol
|
Solidity
| false |
428132995
|
0xAymane/OhmFork
|
3c29467ab41468b7710ec4e9c730e813b306de31
|
staking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 137,850 | 12,920 |
c5e9d0831230a47096a04140a52a4746015be8b510505e65f0c775c1142499a1
| 14,884 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f3/f3a56436b92101353bf3daaaa1ac27ad210630e8_Rothschild_Vinery_Test.sol
| 4,381 | 13,810 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
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 mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Rothschild_Vinery_Test {
using SafeMath for uint256;
uint256 public EGGS_TO_HIRE_1MINERS = 720000;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public REFERRAL = 100;
uint256 public TAX = 10;
uint256 public MARKET_EGGS_DIVISOR = 2; // 50%
uint256 public MARKET_EGGS_DIVISOR_SELL = 1; // 100%
uint256 public MIN_INVEST_LIMIT = 1 * 1e17;
uint256 public WALLET_DEPOSIT_LIMIT = 500 * 1e18;
uint256 public COMPOUND_BONUS = 20;
uint256 public COMPOUND_BONUS_MAX_TIMES = 10;
uint256 public COMPOUND_STEP = 24 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 990;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 5; // compound days, for no tax withdrawal.
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 public marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
uint256 public CUTOFF_STEP = 36 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address public owner;
address payable public dev1;
address payable public dev2;
address payable public dev3;
address payable public dev4;
address payable public mkt;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address payable _dev1, address payable _dev2, address payable _dev3, address payable _dev4, address payable _mkt) {
require(!isContract(_dev1) && !isContract(_dev2) && !isContract(_dev3) && !isContract(_dev4) && !isContract(_mkt));
owner = msg.sender;
dev1 = _dev1;
dev2 = _dev2;
dev3 = _dev3;
dev4 = _dev4;
mkt = _mkt;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function hatchEggs(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not started yet.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function sellEggs() public{
require(contractStarted);
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
user.dailyCompoundBonus = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
payable(address(msg.sender)).transfer(eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function buyEggs(address ref, uint256 amount) public payable{
require(contractStarted);
User storage user = users[msg.sender];
require(amount >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(amount) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(amount);
user.initialDeposit = user.initialDeposit.add(amount);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = msg.value.mul(REFERRAL).div(PERCENTS_DIVIDER);
payable(address(upline)).transfer(refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(amount);
totalStaked = totalStaked.add(amount.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hatchEggs(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
dev1.transfer(tax);
dev2.transfer(tax);
dev3.transfer(tax);
dev4.transfer(tax);
mkt.transfer(tax);
return tax.mul(5);
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function initialize(uint256 amount) public{
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 57542400000;
buyEggs(msg.sender, amount);
} else revert("Contract not yet started.");
}
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN, bs), SafeMath.add(PSNH, SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs), SafeMath.mul(PSNH, rt)), rt)));
}
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%, 1080000 - 8%
// 959000 - 9%, 864000 - 10%, 720000 - 12%, 575424 - 15%, 540000 - 16%, 479520 - 18%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 2592000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 100);
TAX = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 100);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 990);
WITHDRAWAL_TAX = value;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_STEP = value * 60 * 60;
}
function SET_MIN_INVEST_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e17;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 20);
WALLET_DEPOSIT_LIMIT = value * 1e18;
}
}
| 116,589 | 12,921 |
5cca72419caa350262d564d9643a1a05a6caa2538515c9f35c2cc0f06a48842f
| 14,803 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Lending and Borrowing/FlashLoan Attack/Pump and Arbitrage Attack/venus/Governance/GovernorAlpha.sol
| 3,497 | 14,489 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "Venus Governor Alpha";
function quorumVotes() public pure returns (uint) { return 600000e18; } // 600,000 = 2% of XVS
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public pure returns (uint) { return 300000e18; } // 300,000 = 1% of XVS
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { return 60 * 60 * 24 * 3 / 3; } // ~3 days in blocks (assuming 3s blocks)
/// @notice The address of the Venus Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Venus governance token
XVSInterface public xvs;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address timelock_, address xvs_, address guardian_) public {
timelock = TimelockInterface(timelock_);
xvs = XVSInterface(xvs_);
guardian = guardian_;
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(xvs.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = add256(block.timestamp, timelock.delay());
for (uint i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(msg.sender == guardian || xvs.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");
proposal.canceled = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
uint96 votes = xvs.getPriorVotes(voter, proposal.startBlock);
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 __acceptAdmin() public {
require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");
timelock.acceptAdmin();
}
function __abdicate() public {
require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");
guardian = address(0);
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
interface XVSInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}
| 67,097 | 12,922 |
9248578bb68a72450e05bc5572b7e6ea5c9610ed4ce802ff43ba54da62c79f49
| 17,391 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/nonStandarNaming/0x012bf38b6ca9ea39ea95f30f8640f3d63767dd17_nonStandardNaming.sol
| 5,080 | 15,933 |
pragma solidity ^0.5.16;
interface IERC20 {
function TOTALSUPPLY344() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF995(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER795(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE796(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE408(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM856(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function DECIMALS615() external view returns (uint); //inject NONSTANDARD NAMING
event TRANSFER370(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL858(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
library SafeMath {
function ADD697(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB109(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB109(a, b, "SafeMath: subtraction overflow");
}
function SUB109(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function MUL960(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function DIV581(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV581(a, b, "SafeMath: division by zero");
}
function DIV581(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function MOD970(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD970(a, b, "SafeMath: modulo by zero");
}
function MOD970(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function ISCONTRACT908(address account) internal view returns (bool) { //inject NONSTANDARD NAMING
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function TOPAYABLE655(address account) internal pure returns (address payable) { //inject NONSTANDARD NAMING
return address(uint160(account));
}
function SENDVALUE370(address payable recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function SAFETRANSFER212(IERC20 token, address to, uint256 value) internal { //inject NONSTANDARD NAMING
CALLOPTIONALRETURN170(token, abi.encodeWithSelector(token.TRANSFER795.selector, to, value));
}
function SAFETRANSFERFROM22(IERC20 token, address from, address to, uint256 value) internal { //inject NONSTANDARD NAMING
CALLOPTIONALRETURN170(token, abi.encodeWithSelector(token.TRANSFERFROM856.selector, from, to, value));
}
function SAFEAPPROVE493(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
require((value == 0) || (token.ALLOWANCE796(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
CALLOPTIONALRETURN170(token, abi.encodeWithSelector(token.APPROVE408.selector, spender, value));
}
function CALLOPTIONALRETURN170(IERC20 token, bytes memory data) private { //inject NONSTANDARD NAMING
require(address(token).ISCONTRACT908(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Controller {
function VAULTS291(address) external view returns (address); //inject NONSTANDARD NAMING
}
interface Balancer {
function JOINPOOL849(uint,uint[] calldata) external; //inject NONSTANDARD NAMING
function EXITPOOL804(uint,uint[] calldata) external; //inject NONSTANDARD NAMING
}
interface MStable {
function MINT666(address, uint) external; //inject NONSTANDARD NAMING
function REDEEM500(address, uint) external; //inject NONSTANDARD NAMING
}
contract StrategyBalancerMTA {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address constant public want295 = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48); //inject NONSTANDARD NAMING
address constant public musd674 = address(0xe2f2a5C287993345a840Db3B0845fbC70f5935a5); //inject NONSTANDARD NAMING
address constant public balancer837 = address(0x72Cd8f4504941Bf8c5a21d1Fd83A96499FD71d2C); //inject NONSTANDARD NAMING
address public governance;
address public controller;
bool public breaker = false;
// Supply tracks the number of `want` that we have lent out of other distro's
uint public supply = 0;
constructor(address _controller) public {
governance = msg.sender;
controller = _controller;
}
function SETBREAKER384(bool _breaker) public { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
breaker = _breaker;
}
function DEPOSIT98() external { //inject NONSTANDARD NAMING
require(breaker == false, "!breaker");
uint _balance = IERC20(want295).BALANCEOF995(address(this));
uint _want = _balance.DIV581(2);
IERC20(want295).SAFEAPPROVE493(musd674, 0);
IERC20(want295).SAFEAPPROVE493(musd674, _want);
uint _before = _balance;
MStable(musd674).MINT666(want295, _want);
uint _after = IERC20(want295).BALANCEOF995(address(this));
supply = supply.ADD697(_before.SUB109(_after));
uint _musd = IERC20(musd674).BALANCEOF995(address(this));
uint _total = IERC20(balancer837).TOTALSUPPLY344();
uint _balancerMUSD = IERC20(musd674).BALANCEOF995(balancer837);
uint _poolAmountMUSD = _musd.MUL960(_total).DIV581(_balancerMUSD);
uint _balancerUSDC = IERC20(want295).BALANCEOF995(balancer837);
uint _poolAmountUSDC = _want.MUL960(_total).DIV581(_balancerUSDC);
uint _poolAmountOut = _poolAmountMUSD;
if (_poolAmountUSDC < _poolAmountOut) {
_poolAmountOut = _poolAmountUSDC;
}
IERC20(want295).SAFEAPPROVE493(balancer837, 0);
IERC20(want295).SAFEAPPROVE493(balancer837, _want);
IERC20(musd674).SAFEAPPROVE493(balancer837, 0);
IERC20(musd674).SAFEAPPROVE493(balancer837, _musd);
uint[] memory _maxAmountIn = new uint[](2);
_maxAmountIn[0] = _musd;
_maxAmountIn[1] = _want;
_before = IERC20(want295).BALANCEOF995(address(this));
Balancer(balancer837).JOINPOOL849(_poolAmountOut, _maxAmountIn);
_after = IERC20(want295).BALANCEOF995(address(this));
supply = supply.ADD697(_before.SUB109(_after));
}
// Controller only function for creating additional rewards from dust
function WITHDRAW505(IERC20 _asset) external returns (uint balance) { //inject NONSTANDARD NAMING
require(msg.sender == controller, "!controller");
require(address(_asset) != want295, "!c");
require(address(_asset) != musd674, "!c");
require(address(_asset) != balancer837, "!c");
balance = _asset.BALANCEOF995(address(this));
_asset.SAFETRANSFER212(controller, balance);
}
function WITHDRAWM660(uint _amount) internal returns (uint) { //inject NONSTANDARD NAMING
if (_amount > supply) {
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.SUB109(_amount);
}
uint _before = IERC20(want295).BALANCEOF995(address(this));
MStable(musd674).REDEEM500(want295, _amount);
uint _after = IERC20(want295).BALANCEOF995(address(this));
return _after.SUB109(_before);
}
function WITHDRAWBPT914(uint _amount) internal returns (uint) { //inject NONSTANDARD NAMING
uint _calc = CALCULATERATIO430(_amount);
_amount = _amount.SUB109(_amount.MUL960(10).DIV581(10000));
return _WITHDRAWSOME884(_calc, _amount);
}
// Withdraw partial funds, normally used with a vault withdrawal
function WITHDRAW505(uint _amount) external { //inject NONSTANDARD NAMING
require(msg.sender == controller, "!controller");
uint _balance = IERC20(want295).BALANCEOF995(address(this));
if (_balance < _amount) {
uint _musd = NORMALIZE117(IERC20(musd674).BALANCEOF995(address(this)));
uint _remainder = _amount.SUB109(_balance);
if (_musd > 0) {
if (_musd > _remainder) {
_amount = WITHDRAWM660(_remainder);
_amount = _amount.ADD697(_balance);
} else {
_remainder = _remainder.SUB109(_musd);
uint _withdrew = WITHDRAWM660(_musd);
_amount = _withdrew.ADD697(_balance);
_withdrew = WITHDRAWBPT914(_remainder);
_amount = _amount.ADD697(_withdrew);
}
} else {
_amount = WITHDRAWBPT914(_remainder);
_amount = _amount.ADD697(_balance);
}
}
IERC20(want295).SAFETRANSFER212(controller, _amount);
}
function REDEEM500() external { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
uint _balance = NORMALIZE117(IERC20(musd674).BALANCEOF995(address(this)));
if (_balance > supply) {
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.SUB109(_balance);
}
MStable(musd674).REDEEM500(want295, _balance);
}
// Withdraw all funds, normally used when migrating strategies
function WITHDRAWALL744() external returns (uint balance) { //inject NONSTANDARD NAMING
require(msg.sender == controller, "!controller");
_WITHDRAWALL952();
balance = IERC20(want295).BALANCEOF995(address(this));
IERC20(want295).SAFETRANSFER212(controller, balance);
}
function _WITHDRAWALL952() internal { //inject NONSTANDARD NAMING
uint _bpt = IERC20(balancer837).BALANCEOF995(address(this));
uint[] memory _minAmountOut = new uint[](2);
_minAmountOut[0] = 0;
_minAmountOut[1] = 0;
uint _before = IERC20(want295).BALANCEOF995(address(this));
Balancer(balancer837).EXITPOOL804(_bpt, _minAmountOut);
uint _after = IERC20(want295).BALANCEOF995(address(this));
uint _diff = _after.SUB109(_before);
if (_diff > supply) {
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.SUB109(_after.SUB109(_before));
}
uint _musd = IERC20(musd674).BALANCEOF995(address(this));
// This one is the exception because it assumes we can redeem 1 USDC
_diff = NORMALIZE117(_musd);
if (_diff > supply) {
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.SUB109(_diff);
}
MStable(musd674).REDEEM500(want295, _diff);
}
function CALCULATERATIO430(uint _amount) public view returns (uint) { //inject NONSTANDARD NAMING
uint _musd = NORMALIZE117(IERC20(musd674).BALANCEOF995(balancer837));
uint _want = IERC20(want295).BALANCEOF995(balancer837);
uint _total = _musd.ADD697(_want);
uint _ratio = _amount.MUL960(_want).DIV581(_total);
return _ratio;
}
function _WITHDRAWSOME884(uint256 _amount, uint _max) internal returns (uint) { //inject NONSTANDARD NAMING
uint _redeem = IERC20(balancer837).TOTALSUPPLY344().MUL960(_amount).DIV581(IERC20(want295).BALANCEOF995(balancer837));
if (_redeem > IERC20(balancer837).BALANCEOF995(address(this))) {
_redeem = IERC20(balancer837).BALANCEOF995(address(this));
}
uint[] memory _minAmountOut = new uint[](2);
_minAmountOut[0] = 0;
_minAmountOut[1] = 0;
uint _before = IERC20(want295).BALANCEOF995(address(this));
uint _mBefore = IERC20(musd674).BALANCEOF995(address(this));
Balancer(balancer837).EXITPOOL804(_redeem, _minAmountOut);
uint _mAfter = IERC20(musd674).BALANCEOF995(address(this));
uint _after = IERC20(want295).BALANCEOF995(address(this));
uint _musd = _mAfter.SUB109(_mBefore);
uint _withdrew = _after.SUB109(_before);
if (_withdrew > supply) {
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.SUB109(_withdrew);
}
_musd = NORMALIZE117(_musd);
if (_musd > supply) {
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.SUB109(_musd);
}
_before = IERC20(want295).BALANCEOF995(address(this));
MStable(musd674).REDEEM500(want295, _musd);
_after = IERC20(want295).BALANCEOF995(address(this));
_withdrew = _withdrew.ADD697(_after.SUB109(_before));
// Apply the fee as a difference
_withdrew = _withdrew.SUB109(_musd.SUB109(_after.SUB109(_before)));
if (_withdrew > _max) {
_withdrew = _max;
}
return _withdrew;
}
function NORMALIZE117(uint _amount) public view returns (uint) { //inject NONSTANDARD NAMING
return _amount.MUL960(10**IERC20(want295).DECIMALS615()).DIV581(10**IERC20(musd674).DECIMALS615());
}
function BALANCEOF995() public view returns (uint) { //inject NONSTANDARD NAMING
return IERC20(want295).BALANCEOF995(address(this))
.ADD697(supply);
}
function SETGOVERNANCE741(address _governance) external { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
governance = _governance;
}
function SETCONTROLLER847(address _controller) external { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
controller = _controller;
}
}
| 278,869 | 12,923 |
f18e9f47ee30bae2bcba6a8760b4c7a9cc4fe659c82ca1bf6c96ee1eadb2d6eb
| 19,078 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x954e3affbb76333e4d37f89bf1cd5830cd9c61bb.sol
| 4,113 | 15,541 |
pragma solidity ^0.4.20;
contract Harj {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Harj Coin";
string public symbol = "Harj";
uint8 constant public decimals = 18;
/// @dev 10% dividends for token purchase
uint8 constant internal entryFee_ = 10;
/// @dev 0% dividends for token transfer
uint8 constant internal transferFee_ = 0;
/// @dev 10% dividends for token selling
uint8 constant internal exitFee_ = 10;
/// @dev 33% of entryFee_ (i.e. 3% dividends) is given to referrer
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 25 tokens)
uint256 public stakingRequirement = 25e18;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 177,128 | 12,924 |
87820babbfa5c851222e1b0577c1bea6626c54bdcde6e4f7e0ed40410cc22f09
| 32,386 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/unhandledException/0x2d481dbda81896a0046a34de82caf231ea95cabd_unhandledException.sol
| 3,494 | 13,449 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = (false, bytes(msg.data));
recipient.call{ value: amount }(""); //inject UNHANDLED EXCEPTION
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) = (false, bytes(msg.data));
target.call{ value: weiValue }(data); //inject UNHANDLED EXCEPTION
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract 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 ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// CityToken with Governance.
contract AthensCityToken is ERC20("ATHENS.cityswap.io", "ATHENS"), Ownable {
uint256 public constant MAX_SUPPLY = 3172000 * 10**18;
function mint(address _to, uint256 _amount) public onlyOwner {
uint256 _totalSupply = totalSupply();
if(_totalSupply.add(_amount) > MAX_SUPPLY) {
_amount = MAX_SUPPLY.sub(_totalSupply);
}
require(_totalSupply.add(_amount) <= MAX_SUPPLY);
_mint(_to, _amount);
}
}
| 278,667 | 12,925 |
47ebf8680bf64516c884c621efe7f32a2a1662155b798abf72d94a74003081cf
| 12,609 |
.sol
|
Solidity
| false |
463779914
|
MaiaDAO/hermes-protocol
|
b987054647dda2b24d0dba6bef2b35bf24207660
|
contracts/ve_dist.sol
| 3,490 | 12,406 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.11;
interface erc20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint amount) external returns (bool);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function balanceOf(address) external view returns (uint);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function approve(address spender, uint value) external returns (bool);
}
library Math {
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
function max(uint a, uint b) internal pure returns (uint) {
return a >= b ? a : b;
}
}
interface VotingEscrow {
struct Point {
int128 bias;
int128 slope; // # -dweight / dt
uint256 ts;
uint256 blk; // block
}
function user_point_epoch(uint tokenId) external view returns (uint);
function epoch() external view returns (uint);
function user_point_history(uint tokenId, uint loc) external view returns (Point memory);
function point_history(uint loc) external view returns (Point memory);
function checkpoint() external;
function deposit_for(uint tokenId, uint value) external;
function token() external view returns (address);
}
contract ve_dist {
event CheckpointToken(uint time,
uint tokens);
event Claimed(uint tokenId,
uint amount,
uint claim_epoch,
uint max_epoch);
uint constant WEEK = 7 * 86400;
uint public start_time;
uint public time_cursor;
mapping(uint => uint) public time_cursor_of;
mapping(uint => uint) public user_epoch_of;
uint public last_token_time;
uint[1000000000000000] public tokens_per_week;
address public voting_escrow;
address public token;
uint public token_last_balance;
uint[1000000000000000] public ve_supply;
address public depositor;
constructor(address _voting_escrow) {
uint _t = block.timestamp / WEEK * WEEK;
start_time = _t;
last_token_time = _t;
time_cursor = _t;
address _token = VotingEscrow(_voting_escrow).token();
token = _token;
voting_escrow = _voting_escrow;
depositor = msg.sender;
erc20(_token).approve(_voting_escrow, type(uint).max);
}
function timestamp() external view returns (uint) {
return block.timestamp / WEEK * WEEK;
}
function _checkpoint_token() internal {
uint token_balance = erc20(token).balanceOf(address(this));
uint to_distribute = token_balance - token_last_balance;
token_last_balance = token_balance;
uint t = last_token_time;
uint since_last = block.timestamp - t;
last_token_time = block.timestamp;
uint this_week = t / WEEK * WEEK;
uint next_week = 0;
for (uint i = 0; i < 20; i++) {
next_week = this_week + WEEK;
if (block.timestamp < next_week) {
if (since_last == 0 && block.timestamp == t) {
tokens_per_week[this_week] += to_distribute;
} else {
tokens_per_week[this_week] += to_distribute * (block.timestamp - t) / since_last;
}
break;
} else {
if (since_last == 0 && next_week == t) {
tokens_per_week[this_week] += to_distribute;
} else {
tokens_per_week[this_week] += to_distribute * (next_week - t) / since_last;
}
}
t = next_week;
this_week = next_week;
}
emit CheckpointToken(block.timestamp, to_distribute);
}
function checkpoint_token() external {
assert(msg.sender == depositor);
_checkpoint_token();
}
function _find_timestamp_epoch(address ve, uint _timestamp) internal view returns (uint) {
uint _min = 0;
uint _max = VotingEscrow(ve).epoch();
for (uint i = 0; i < 128; i++) {
if (_min >= _max) break;
uint _mid = (_min + _max + 2) / 2;
VotingEscrow.Point memory pt = VotingEscrow(ve).point_history(_mid);
if (pt.ts <= _timestamp) {
_min = _mid;
} else {
_max = _mid - 1;
}
}
return _min;
}
function _find_timestamp_user_epoch(address ve, uint tokenId, uint _timestamp, uint max_user_epoch) internal view returns (uint) {
uint _min = 0;
uint _max = max_user_epoch;
for (uint i = 0; i < 128; i++) {
if (_min >= _max) break;
uint _mid = (_min + _max + 2) / 2;
VotingEscrow.Point memory pt = VotingEscrow(ve).user_point_history(tokenId, _mid);
if (pt.ts <= _timestamp) {
_min = _mid;
} else {
_max = _mid -1;
}
}
return _min;
}
function ve_for_at(uint _tokenId, uint _timestamp) external view returns (uint) {
address ve = voting_escrow;
uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId);
uint epoch = _find_timestamp_user_epoch(ve, _tokenId, _timestamp, max_user_epoch);
VotingEscrow.Point memory pt = VotingEscrow(ve).user_point_history(_tokenId, epoch);
return Math.max(uint(int256(pt.bias - pt.slope * (int128(int256(_timestamp - pt.ts))))), 0);
}
function _checkpoint_total_supply() internal {
address ve = voting_escrow;
uint t = time_cursor;
uint rounded_timestamp = block.timestamp / WEEK * WEEK;
VotingEscrow(ve).checkpoint();
for (uint i = 0; i < 20; i++) {
if (t > rounded_timestamp) {
break;
} else {
uint epoch = _find_timestamp_epoch(ve, t);
VotingEscrow.Point memory pt = VotingEscrow(ve).point_history(epoch);
int128 dt = 0;
if (t > pt.ts) {
dt = int128(int256(t - pt.ts));
}
ve_supply[t] = Math.max(uint(int256(pt.bias - pt.slope * dt)), 0);
}
t += WEEK;
}
time_cursor = t;
}
function checkpoint_total_supply() external {
_checkpoint_total_supply();
}
function _claim(uint _tokenId, address ve, uint _last_token_time) internal returns (uint) {
uint user_epoch = 0;
uint to_distribute = 0;
uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId);
uint _start_time = start_time;
if (max_user_epoch == 0) return 0;
uint week_cursor = time_cursor_of[_tokenId];
if (week_cursor == 0) {
user_epoch = _find_timestamp_user_epoch(ve, _tokenId, _start_time, max_user_epoch);
} else {
user_epoch = user_epoch_of[_tokenId];
}
if (user_epoch == 0) user_epoch = 1;
VotingEscrow.Point memory user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch);
if (week_cursor == 0) week_cursor = (user_point.ts + WEEK - 1) / WEEK * WEEK;
if (week_cursor >= last_token_time) return 0;
if (week_cursor < _start_time) week_cursor = _start_time;
VotingEscrow.Point memory old_user_point;
for (uint i = 0; i < 50; i++) {
if (week_cursor >= _last_token_time) break;
if (week_cursor >= user_point.ts && user_epoch <= max_user_epoch) {
user_epoch += 1;
old_user_point = user_point;
if (user_epoch > max_user_epoch) {
user_point = VotingEscrow.Point(0,0,0,0);
} else {
user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch);
}
} else {
int128 dt = int128(int256(week_cursor - old_user_point.ts));
uint balance_of = Math.max(uint(int256(old_user_point.bias - dt * old_user_point.slope)), 0);
if (balance_of == 0 && user_epoch > max_user_epoch) break;
if (balance_of > 0) {
to_distribute += balance_of * tokens_per_week[week_cursor] / ve_supply[week_cursor];
}
week_cursor += WEEK;
}
}
user_epoch = Math.min(max_user_epoch, user_epoch - 1);
user_epoch_of[_tokenId] = user_epoch;
time_cursor_of[_tokenId] = week_cursor;
emit Claimed(_tokenId, to_distribute, user_epoch, max_user_epoch);
return to_distribute;
}
function _claimable(uint _tokenId, address ve, uint _last_token_time) internal view returns (uint) {
uint user_epoch = 0;
uint to_distribute = 0;
uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId);
uint _start_time = start_time;
if (max_user_epoch == 0) return 0;
uint week_cursor = time_cursor_of[_tokenId];
if (week_cursor == 0) {
user_epoch = _find_timestamp_user_epoch(ve, _tokenId, _start_time, max_user_epoch);
} else {
user_epoch = user_epoch_of[_tokenId];
}
if (user_epoch == 0) user_epoch = 1;
VotingEscrow.Point memory user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch);
if (week_cursor == 0) week_cursor = (user_point.ts + WEEK - 1) / WEEK * WEEK;
if (week_cursor >= last_token_time) return 0;
if (week_cursor < _start_time) week_cursor = _start_time;
VotingEscrow.Point memory old_user_point;
for (uint i = 0; i < 50; i++) {
if (week_cursor >= _last_token_time) break;
if (week_cursor >= user_point.ts && user_epoch <= max_user_epoch) {
user_epoch += 1;
old_user_point = user_point;
if (user_epoch > max_user_epoch) {
user_point = VotingEscrow.Point(0,0,0,0);
} else {
user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch);
}
} else {
int128 dt = int128(int256(week_cursor - old_user_point.ts));
uint balance_of = Math.max(uint(int256(old_user_point.bias - dt * old_user_point.slope)), 0);
if (balance_of == 0 && user_epoch > max_user_epoch) break;
if (balance_of > 0) {
to_distribute += balance_of * tokens_per_week[week_cursor] / ve_supply[week_cursor];
}
week_cursor += WEEK;
}
}
return to_distribute;
}
function claimable(uint _tokenId) external view returns (uint) {
uint _last_token_time = last_token_time / WEEK * WEEK;
return _claimable(_tokenId, voting_escrow, _last_token_time);
}
function claim(uint _tokenId) external returns (uint) {
if (block.timestamp >= time_cursor) _checkpoint_total_supply();
uint _last_token_time = last_token_time;
_last_token_time = _last_token_time / WEEK * WEEK;
uint amount = _claim(_tokenId, voting_escrow, _last_token_time);
if (amount != 0) {
VotingEscrow(voting_escrow).deposit_for(_tokenId, amount);
token_last_balance -= amount;
}
return amount;
}
function claim_many(uint[] memory _tokenIds) external returns (bool) {
if (block.timestamp >= time_cursor) _checkpoint_total_supply();
uint _last_token_time = last_token_time;
_last_token_time = _last_token_time / WEEK * WEEK;
address _voting_escrow = voting_escrow;
uint total = 0;
for (uint i = 0; i < _tokenIds.length; i++) {
uint _tokenId = _tokenIds[i];
if (_tokenId == 0) break;
uint amount = _claim(_tokenId, _voting_escrow, _last_token_time);
if (amount != 0) {
VotingEscrow(_voting_escrow).deposit_for(_tokenId, amount);
total += amount;
}
}
if (total != 0) {
token_last_balance -= total;
}
return true;
}
// Once off event on contract initialize
function setDepositor(address _depositor) external {
require(msg.sender == depositor);
depositor = _depositor;
}
}
| 17,692 | 12,926 |
690ac5850b61deb41643814466515a444722d2e9fcab8220bf8771babc1a65fa
| 21,973 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x06e4c89135ca81e4f22e2f0e7a27bf0bdb80209c.sol
| 3,872 | 14,750 |
pragma solidity ^0.4.18;
// zeppelin-solidity: 1.5.0
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 Object is StandardToken, Ownable {
string public name;
string public symbol;
uint8 public constant decimals = 18;
bool public mintingFinished = false;
event Burn(address indexed burner, uint value);
event Mint(address indexed to, uint amount);
event MintFinished();
modifier canMint() {
require(!mintingFinished);
_;
}
function Object(string _name, string _symbol) public {
name = _name;
symbol = _symbol;
}
function burn(uint _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
function mint(address _to, uint _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;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_value % (1 ether) == 0); // require whole token transfers
// 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;
}
}
contract Shop is Ownable {
using SafeMath for *;
struct ShopSettings {
address bank;
uint32 startTime;
uint32 endTime;
uint fundsRaised;
uint rate;
uint price;
//uint recommendedBid;
}
Object public object;
ShopSettings public shopSettings;
modifier onlyValidPurchase() {
require(msg.value % shopSettings.price == 0); // whole numbers only
require((now >= shopSettings.startTime && now <= shopSettings.endTime) && msg.value != 0);
_;
}
modifier whenClosed() { // not actually implemented?
require(now > shopSettings.endTime);
_;
}
modifier whenOpen() {
require(now < shopSettings.endTime);
_;
}
modifier onlyValidAddress(address _bank) {
require(_bank != address(0));
_;
}
modifier onlyOne() {
require(calculateTokens() == 1 ether);
_;
}
modifier onlyBuyer(address _beneficiary) {
require(_beneficiary == msg.sender);
_;
}
event ShopClosed(uint32 date);
event ObjectPurchase(address indexed purchaser, address indexed beneficiary, uint value, uint amount);
function () external payable {
buyObject(msg.sender);
}
function Shop(address _bank, string _name, string _symbol, uint _rate, uint32 _endTime)
onlyValidAddress(_bank) public {
require(_rate >= 0);
require(_endTime > now);
shopSettings = ShopSettings(_bank, uint32(now), _endTime, 0, _rate, 0);
calculatePrice(); // set initial price based on initial rate
object = new Object(_name, _symbol);
}
function buyObject(address _beneficiary) onlyValidPurchase
onlyBuyer(_beneficiary)
onlyValidAddress(_beneficiary) public payable {
uint numTokens = calculateTokens();
shopSettings.fundsRaised = shopSettings.fundsRaised.add(msg.value);
object.mint(_beneficiary, numTokens);
ObjectPurchase(msg.sender, _beneficiary, msg.value, numTokens);
forwardFunds();
}
function calculateTokens() internal returns(uint) {
// rate is literally tokens per eth in wei;
// rate is always 1/price!
calculatePrice(); // update price
return msg.value.mul(1 ether).div(1 ether.mul(1 ether).div(shopSettings.rate));
}
function calculatePrice() internal returns(uint) {
shopSettings.price = (1 ether).mul(1 ether).div(shopSettings.rate); // update price based on current rate
}
function closeShop() onlyOwner whenOpen public {
shopSettings.endTime = uint32(now);
ShopClosed(uint32(now));
}
function forwardFunds() internal {
shopSettings.bank.transfer(msg.value);
}
}
contract EnchantedShop is Shop {
using SafeMath for *;
mapping(address => uint) public balanceOwed; // balances owed to individual addresses
mapping(address => uint) public latestBalanceCheck; // latest balance check of individual addresses
mapping(address => uint) public itemsOwned;
//mapping(address => uint) public totalWithdrawn; // used in calculating total earnings
mapping(address => uint) public excessEth; // excess eth sent by individual addresses
uint public itemReturn;
uint public maxDebt; // maximum possible debt owed by the shop if no funds were claimed
uint public runningDebt; // total of individually amortized debts owed by this shop
uint public additionalDebt; // general debt not yet accounted for due to amortization
uint public debtPaid; // total debt paid by this shop
uint public constant devFee = 250; // 125 represents 12.5%
uint public originalPrice;
uint public totalExcessEth; // total of individually amortized excess eth transfers, analogous to runningDebt
bool public lock;
uint public unlockDate;
event ShopDeployed(address wallet, uint rate, uint itemReturn, uint32 endTime);
//event EnchantedObjectMinted(uint totalSupply);
event PriceUpdate(uint price);
event FundsMoved(uint amount);
event SafeLocked(uint date);
event StartedSafeUnlock(uint date);
event WillWithdraw(uint amount);
modifier onlyContributors {
require(itemsOwned[msg.sender] > 0);
_;
}
modifier onlyValidPurchase() {
require(msg.value >= shopSettings.price); // at least enough for 1
require((now >= shopSettings.startTime && now <= shopSettings.endTime) && msg.value != 0);
_;
}
function EnchantedShop(address _bank, string _name, string _symbol, uint _rate, uint32 _endTime, uint _itemReturn)
Shop(_bank, _name, _symbol, _rate, _endTime) public
{
require(_itemReturn == shopSettings.price.div(100)); // safety check; ensure we're using 1% returns and that we're using the correct price
itemReturn = _itemReturn; // return should be in given wei
originalPrice = shopSettings.price;
ShopDeployed(_bank, _rate, _itemReturn, _endTime);
unlockDate = 0;
lock = true;
SafeLocked(now);
}
function calculateTokens() internal returns(uint) {
// rate is literally tokens per eth in wei;
calculatePrice(); // update price based on current rate
return (1 ether);
}
function forwardFunds() internal {
uint fee = shopSettings.price.mul(devFee).div(1000);
uint supply = object.totalSupply();
if (msg.value > shopSettings.price) { // if sender sent extra eth, account for it so we can send it back later
excessEth[msg.sender] = excessEth[msg.sender].add(msg.value.sub(shopSettings.price));
totalExcessEth = totalExcessEth.add(msg.value.sub(shopSettings.price));
}
shopSettings.bank.transfer(fee);
itemsOwned[msg.sender] = itemsOwned[msg.sender].add(1 ether);
// update caller's balance and our debt
uint earnings = (itemsOwned[msg.sender].div(1 ether).sub(1)).mul(supply.sub(latestBalanceCheck[msg.sender])).div(1 ether).mul(itemReturn);
if (latestBalanceCheck[msg.sender] != 0) { // if this isn't the first time we've checked buyer's balance owed...
balanceOwed[msg.sender] = balanceOwed[msg.sender].add(earnings);
runningDebt = runningDebt.add(earnings);
}
latestBalanceCheck[msg.sender] = supply;
maxDebt = maxDebt.add((supply.sub(1 ether)).div(1 ether).mul(itemReturn)); // update maxDebt given the new item total
additionalDebt = maxDebt.sub(runningDebt).sub(debtPaid); // update total debt not yet accounted for due to amoritzation
if (additionalDebt < 0) { // this check may be unnecessary but may have been needed for the prototype
additionalDebt = 0;
}
// update price of item (using rate for scalability) so that we can always cover fee + returns
if (supply.div(1 ether).mul(itemReturn).add(runningDebt).add(additionalDebt) > (this.balance.sub(totalExcessEth))) {
shopSettings.rate = (1 ether).mul(1 ether).div(supply.div(1 ether).mul(itemReturn).mul(1000).div((uint(1000).sub(devFee))));
calculatePrice(); // update price
PriceUpdate(shopSettings.price);
}
//EnchantedObjectMinted(supply); // FIX THIS
}
function claimFunds() onlyContributors public {
// must use onlyContributors (itemsOwned > 0) as a check here!
uint latest = latestBalanceCheck[msg.sender];
uint supply = object.totalSupply();
uint balance = balanceOwed[msg.sender];
uint earnings = itemsOwned[msg.sender].div(1 ether).mul(supply.sub(latest)).div(1 ether).mul(itemReturn);
uint excess = excessEth[msg.sender];
// update latestBalanceCheck, reset balance owed to caller, and reset excess eth owed to caller
latestBalanceCheck[msg.sender] = supply;
balanceOwed[msg.sender] = 0;
excessEth[msg.sender] = 0;
balance = balance.add(earnings);
// next, update our debt:
runningDebt = runningDebt.add(earnings);
runningDebt = runningDebt.sub(balance); // might be going negative due to not adding the excess eth send to runningDebt
debtPaid = debtPaid.add(balance);
// account for excess Eth
balance = balance.add(excess);
totalExcessEth = totalExcessEth.sub(excess);
WillWithdraw(balance);
// finally, send balance owed to msg.sender
require(balance > 0);
msg.sender.transfer(balance);
//totalWithdrawn[msg.sender] = totalWithdrawn[msg.sender].add(balance.sub(excess));
// might want to return bool
}
function startUnlock()
onlyOwner public
{
require(lock && now.sub(unlockDate) > 2 weeks);
unlockDate = now + 2 weeks;
lock = false;
StartedSafeUnlock(now);
}
function emergencyWithdraw(uint amount, bool relock)
onlyOwner public
{
require(!lock && now > unlockDate);
shopSettings.bank.transfer(amount);
if (relock) {
lock = relock;
SafeLocked(now);
}
}
}
| 215,703 | 12,927 |
0bdd7912fcba664f81d85245fc52a4846bdcf8ce132fd1d4dec04a89891a7104
| 25,902 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x325351388c17c72bf3c3a5e3e7a21b62be028dc5.sol
| 4,359 | 15,600 |
pragma solidity 0.4.23;
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
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: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
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;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
// File: zeppelin-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, 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);
}
}
// File: contracts/UppsalaToken.sol
contract UppsalaToken is MintableToken, PausableToken {
string public constant name = 'SENTINEL PROTOCOL';
string public constant symbol = 'UPP';
uint8 public constant decimals = 18;
}
// File: zeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/CappedCrowdsale.sol
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
// File: contracts/UserMinMaxCrowdsale.sol
contract UserMinMaxCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
uint256 public min;
uint256 public max;
mapping(address => uint256) public contributions;
function UserMinMaxCrowdsale(uint256 _min, uint256 _max) public {
require(_min > 0);
require(_max > _min);
// each person should contribute between min-max amount of wei
min = _min;
max = _max;
}
function getUserContribution(address _beneficiary) public view returns (uint256) {
return contributions[_beneficiary];
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(contributions[_beneficiary].add(_weiAmount) <= max);
require(contributions[_beneficiary].add(_weiAmount) >= min);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
super._updatePurchasingState(_beneficiary, _weiAmount);
// update total contribution
contributions[_beneficiary] = contributions[_beneficiary].add(_weiAmount);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
// solium-disable-next-line security/no-block-members
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/WhitelistedCrowdsale.sol
contract WhitelistedCrowdsale is Crowdsale, Ownable {
mapping(address => bool) public whitelist;
modifier isWhitelisted(address _beneficiary) {
require(whitelist[_beneficiary]);
_;
}
function addToWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = true;
}
function addManyToWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: contracts/UppsalaPresale.sol
contract UppsalaPresale is WhitelistedCrowdsale, UserMinMaxCrowdsale, CappedCrowdsale,
TimedCrowdsale, Pausable {
using SafeMath for uint256;
mapping(address => uint256) public balances;
mapping(address => uint256) public lockedBalances;
uint256 public bonusRate;
uint256 public withdrawTime;
uint256 public releaseTime;
uint256 public totalBonusGiven;
event BonusRelease(address beneficiary, uint256 value);
function UppsalaPresale(uint256 rate,
uint256 openTime,
uint256 closeTime,
uint256 totalCap,
uint256 userMin,
uint256 userMax,
uint256 _withdrawTime,
uint256 _bonusRate,
uint256 _releaseTime,
address account,
StandardToken token)
Crowdsale(rate, account, token)
TimedCrowdsale(openTime, closeTime)
CappedCrowdsale(totalCap)
UserMinMaxCrowdsale(userMin, userMax) public
{
require(_bonusRate > 0);
require(_releaseTime > block.timestamp);
require(_withdrawTime > block.timestamp);
bonusRate = _bonusRate;
releaseTime = _releaseTime;
withdrawTime = _withdrawTime;
totalBonusGiven = 0;
}
function withdrawTokens(address _beneficiary) public {
require(block.timestamp > withdrawTime);
uint256 amount = balances[_beneficiary];
require(amount > 0);
balances[_beneficiary] = 0;
_deliverTokens(_beneficiary, amount);
}
function _processPurchase(address _beneficiary,
uint256 _tokenAmount)
internal
{
balances[_beneficiary] = balances[_beneficiary].add(_tokenAmount);
}
function buyTokens(address beneficiary) public payable whenNotPaused {
// Limiting gas price
require(tx.gasprice <= 50000000000 wei);
// Limiting gaslimit (should be up to around 200000-210000)
require(msg.gas <= 190000);
require(beneficiary != address(0));
super.buyTokens(beneficiary);
uint256 weiAmount = msg.value;
// we give 15% of bonus, but lock the balance for 6 months
uint256 bonusAmount = weiAmount.mul(bonusRate);
lockedBalances[beneficiary] = lockedBalances[beneficiary].add(bonusAmount);
totalBonusGiven = totalBonusGiven.add(bonusAmount);
}
function lockedBalanceOf(address _beneficiary) public view returns (uint256) {
return lockedBalances[_beneficiary];
}
function releaseLockedBalance(address _beneficiary) public {
// anyone can call this function to release the lock for the bonus after lock-up period
require(_beneficiary != address(0));
require(block.timestamp >= releaseTime);
uint256 amount = lockedBalances[_beneficiary];
require(amount > 0);
lockedBalances[_beneficiary] = 0;
token.transfer(_beneficiary, amount);
emit BonusRelease(_beneficiary, amount);
}
}
| 206,979 | 12,928 |
481f9694c0b54792b74f5486e40667b3a28fefed99552cd03f9125cf1bf902a3
| 17,194 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBUeCtfweWeEjWYG31Ps7u6CZqEegynaSa_TronHeroMax.sol
| 4,592 | 16,656 |
//SourceUnit: tronheromax.sol
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
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 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TronHeroMax is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 70; //per thousand
uint256 public constant MARKETING_RATE = 70;
uint256 public constant REFERENCE_RATE = 180;
uint256 public constant REFERENCE_LEVEL1_RATE = 100;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant REFERENCE_SELF_RATE = 0;
uint256 public constant MINIMUM = 10000000; //Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 6666;
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address private developerAccount_;
address private marketingAccount_;
address private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(280, 0)); //28% daily, lifetime
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public onlyOwner view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
_refAmount = (_investment.mul(REFERENCE_SELF_RATE)).div(1000);
uid2Investor[_uid].availableReferrerEarnings = _refAmount.add(uid2Investor[_uid].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 284,492 | 12,929 |
c774a298ad677911a022a729d8539a3fd55d27d3c765da26d33f47e6771731e5
| 19,493 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCodpJ32intVraZEvGHgpPfx9uB7u4anhm_Tronwiner.sol
| 4,547 | 17,263 |
//SourceUnit: Tronwiner.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract Tronwiner {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 200;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 1000;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 1500;
uint constant public NETWORK = 1000;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 304,632 | 12,930 |
94f1be708218887240193722d575ad8c4d0b2a4b7263d4f4d001288245cd410c
| 14,910 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xe463d1ee18bcbce681215d15738018eadaa82260.sol
| 2,474 | 9,960 |
pragma solidity ^0.5.0;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address 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 SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws 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);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
contract FIICToken is Ownable {
using SafeMath for uint256;
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 0;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// accounts' lockFund property
struct LockFund {
uint256 amount;
uint256 startTime;
uint256 lockUnit;
uint256 times;
bool recyclable;
}
mapping (address => LockFund) public lockFunds;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// lockFund event
event LockTransfer(address indexed acc, uint256 amount, uint256 startTime, uint256 lockUnit, uint256 times);
// recycle token
event recycleToke(address indexed acc, uint256 amount, uint256 startTime);
constructor(uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0),"");
require(_from != _to,"");
// if lock
require(balanceOf[_from] - getLockedAmount(_from) >= _value,"");
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to],"");
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);//""
}
function getLockedAmount(address _from) public view returns (uint256 lockAmount) {
LockFund memory lockFund = lockFunds[_from];
if(lockFund.amount > 0) {
if(block.timestamp <= lockFund.startTime) {
return lockFund.amount;
}
uint256 ap = lockFund.amount.div(lockFund.times);
// uint256 ap = lockFund.amount / lockFund.times;
// uint256 t = (block.timestamp - lockFund.startTime) / lockFund.lockUnit;
uint256 t = (block.timestamp.sub(lockFund.startTime)).div(lockFund.lockUnit);
if(t < lockFund.times) {
return lockFund.amount.sub(ap.mul(t));
}
}
return 0;
}
function getReleaseAmount(address _from) public view returns (uint256 releaseAmount) {
LockFund memory lockFund = lockFunds[_from];
if(lockFund.amount > 0) {
if(block.timestamp <= lockFund.startTime) {
return 0;
}
uint256 ap = lockFund.amount / lockFund.times;
uint256 t = (block.timestamp - lockFund.startTime) / lockFund.lockUnit;
if(t>= lockFund.times){
return lockFund.amount;
}
return ap * t;
}
return balanceOf[_from];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
function lockTransfer(address _lockAddress, uint256 _lockAmount, uint256 _startReleaseTime, uint256 _releaseInterval, uint256 _releaseTimes,bool _recyclable) onlyOwner public {
// transfer token to _lockAddress
_transfer(msg.sender, _lockAddress, _lockAmount);
// add lockFund
LockFund storage lockFund = lockFunds[_lockAddress];
lockFund.amount = _lockAmount;
lockFund.startTime = _startReleaseTime;
lockFund.lockUnit = _releaseInterval;
lockFund.times = _releaseTimes;
lockFund.recyclable = _recyclable;
emit LockTransfer(_lockAddress, _lockAmount, _startReleaseTime, _releaseInterval, _releaseTimes);
}
function recycleRemainingToken(address _lockAddress) onlyOwner public{
// token
LockFund storage lockFund = lockFunds[_lockAddress];
require(lockFund.recyclable == true,"");
uint256 remaingCount = getLockedAmount(_lockAddress);
// Check for overflows
require(balanceOf[owner()] + remaingCount > balanceOf[owner()],"");
// Save this for an assertion in the future
uint previousBalances = balanceOf[owner()] + balanceOf[_lockAddress];
// Subtract from the sender
balanceOf[_lockAddress] -= remaingCount;
// Add the same to the recipient
balanceOf[owner()] += remaingCount;
lockFund.amount = 0;
emit recycleToke(_lockAddress,remaingCount,block.timestamp);
emit Transfer(_lockAddress, owner(), remaingCount);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[owner()] + balanceOf[_lockAddress] == previousBalances);//""
}
}
| 133,173 | 12,931 |
30e6b414748bf7dab2e4137002c0609ef5627f894393719e727bdf154a3ca4d1
| 11,567 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xce26ead209ba9c7bf9f80312555834d81bf11a08.sol
| 2,484 | 11,036 |
pragma solidity ^0.4.21;
contract Ownable {
address public owner;
event OwnershipTransferred(address previousOwner, address 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 StorageBase is Ownable {
function withdrawBalance() external onlyOwner returns (bool) {
// The owner has a method to withdraw balance from multiple contracts together,
// use send here to make sure even if one withdrawBalance fails the others will still work
bool res = msg.sender.send(address(this).balance);
return res;
}
}
// owner of ActivityStorage should be ActivityCore contract address
contract ActivityStorage is StorageBase {
struct Activity {
// accept bid or not
bool isPause;
// limit max num of monster buyable per address
uint16 buyLimit;
// price (in wei)
uint128 packPrice;
// startDate (in seconds)
uint64 startDate;
// endDate (in seconds)
uint64 endDate;
// packId => address of bid winner
mapping(uint16 => address) soldPackToAddress;
// address => number of success bid
mapping(address => uint16) addressBoughtCount;
}
// limit max activityId to 65536, big enough
mapping(uint16 => Activity) public activities;
function createActivity(uint16 _activityId,
uint16 _buyLimit,
uint128 _packPrice,
uint64 _startDate,
uint64 _endDate)
external
onlyOwner
{
// activity should not exist and can only be initialized once
require(activities[_activityId].buyLimit == 0);
activities[_activityId] = Activity({
isPause: false,
buyLimit: _buyLimit,
packPrice: _packPrice,
startDate: _startDate,
endDate: _endDate
});
}
function sellPackToAddress(uint16 _activityId,
uint16 _packId,
address buyer)
external
onlyOwner
{
Activity storage activity = activities[_activityId];
activity.soldPackToAddress[_packId] = buyer;
activity.addressBoughtCount[buyer]++;
}
function pauseActivity(uint16 _activityId) external onlyOwner {
activities[_activityId].isPause = true;
}
function unpauseActivity(uint16 _activityId) external onlyOwner {
activities[_activityId].isPause = false;
}
function deleteActivity(uint16 _activityId) external onlyOwner {
delete activities[_activityId];
}
function getAddressBoughtCount(uint16 _activityId, address buyer) external view returns (uint16) {
return activities[_activityId].addressBoughtCount[buyer];
}
function getBuyerAddress(uint16 _activityId, uint16 packId) external view returns (address) {
return activities[_activityId].soldPackToAddress[packId];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract HasNoContracts is Pausable {
function reclaimContract(address _contractAddr) external onlyOwner whenPaused {
Ownable contractInst = Ownable(_contractAddr);
contractInst.transferOwnership(owner);
}
}
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
// Events
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
// ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165)
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract LogicBase is HasNoContracts {
/// The ERC-165 interface signature for ERC-721.
/// Ref: https://github.com/ethereum/EIPs/issues/165
/// Ref: https://github.com/ethereum/EIPs/issues/721
bytes4 constant InterfaceSignature_NFC = bytes4(0x9f40b779);
// Reference to contract tracking NFT ownership
ERC721 public nonFungibleContract;
// Reference to storage contract
StorageBase public storageContract;
function LogicBase(address _nftAddress, address _storageAddress) public {
// paused by default
paused = true;
setNFTAddress(_nftAddress);
require(_storageAddress != address(0));
storageContract = StorageBase(_storageAddress);
}
// Very dangerous action, only when new contract has been proved working
// Requires storageContract already transferOwnership to the new contract
// This method is only used to transfer the balance to owner
function destroy() external onlyOwner whenPaused {
address storageOwner = storageContract.owner();
require(storageOwner != address(this));
// Transfers the current balance to the owner and terminates the contract
selfdestruct(owner);
}
// Very dangerous action, only when new contract has been proved working
// Requires storageContract already transferOwnership to the new contract
// This method is only used to transfer the balance to the new contract
function destroyAndSendToStorageOwner() external onlyOwner whenPaused {
address storageOwner = storageContract.owner();
require(storageOwner != address(this));
// Transfers the current balance to the new owner of the storage contract and terminates the contract
selfdestruct(storageOwner);
}
// override to make sure everything is initialized before the unpause
function unpause() public onlyOwner whenPaused {
// can not unpause when the logic contract is not initialzed
require(nonFungibleContract != address(0));
require(storageContract != address(0));
// can not unpause when ownership of storage contract is not the current contract
require(storageContract.owner() == address(this));
super.unpause();
}
function setNFTAddress(address _nftAddress) public onlyOwner {
require(_nftAddress != address(0));
ERC721 candidateContract = ERC721(_nftAddress);
require(candidateContract.supportsInterface(InterfaceSignature_NFC));
nonFungibleContract = candidateContract;
}
// Withdraw balance to the Core Contract
function withdrawBalance() external returns (bool) {
address nftAddress = address(nonFungibleContract);
// either Owner or Core Contract can trigger the withdraw
require(msg.sender == owner || msg.sender == nftAddress);
// The owner has a method to withdraw balance from multiple contracts together,
// use send here to make sure even if one withdrawBalance fails the others will still work
bool res = nftAddress.send(address(this).balance);
return res;
}
function withdrawBalanceFromStorageContract() external returns (bool) {
address nftAddress = address(nonFungibleContract);
// either Owner or Core Contract can trigger the withdraw
require(msg.sender == owner || msg.sender == nftAddress);
// The owner has a method to withdraw balance from multiple contracts together,
// use send here to make sure even if one withdrawBalance fails the others will still work
bool res = storageContract.withdrawBalance();
return res;
}
}
contract ActivityCore is LogicBase {
bool public isActivityCore = true;
ActivityStorage activityStorage;
event ActivityCreated(uint16 activityId);
event ActivityBidSuccess(uint16 activityId, uint16 packId, address winner);
function ActivityCore(address _nftAddress, address _storageAddress)
LogicBase(_nftAddress, _storageAddress) public {
activityStorage = ActivityStorage(_storageAddress);
}
function createActivity(uint16 _activityId,
uint16 _buyLimit,
uint128 _packPrice,
uint64 _startDate,
uint64 _endDate)
external
onlyOwner
whenNotPaused
{
activityStorage.createActivity(_activityId, _buyLimit, _packPrice, _startDate, _endDate);
emit ActivityCreated(_activityId);
}
// Very dangerous action and should be only used for testing
// Must pause the contract first
function deleteActivity(uint16 _activityId)
external
onlyOwner
whenPaused
{
activityStorage.deleteActivity(_activityId);
}
function getActivity(uint16 _activityId)
external
view
returns (bool isPause,
uint16 buyLimit,
uint128 packPrice,
uint64 startDate,
uint64 endDate)
{
return activityStorage.activities(_activityId);
}
function bid(uint16 _activityId, uint16 _packId)
external
payable
whenNotPaused
{
bool isPause;
uint16 buyLimit;
uint128 packPrice;
uint64 startDate;
uint64 endDate;
(isPause, buyLimit, packPrice, startDate, endDate) = activityStorage.activities(_activityId);
// not allow to bid when activity is paused
require(!isPause);
// not allow to bid when activity is not initialized (buyLimit == 0)
require(buyLimit > 0);
// should send enough ether
require(msg.value >= packPrice);
// verify startDate & endDate
require(now >= startDate && now <= endDate);
// this pack is not sold out
require(activityStorage.getBuyerAddress(_activityId, _packId) == address(0));
// buyer not exceed buyLimit
require(activityStorage.getAddressBoughtCount(_activityId, msg.sender) < buyLimit);
// record in blockchain
activityStorage.sellPackToAddress(_activityId, _packId, msg.sender);
// emit the success event
emit ActivityBidSuccess(_activityId, _packId, msg.sender);
}
}
| 219,040 | 12,932 |
e38d368a1fd0e2ec0c4996397a868dd5fade031b3a895b5dd363b2cecc19f9fe
| 17,758 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x47349ebb01fa27bb3ad72995ff7182d949851a93.sol
| 3,593 | 13,859 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 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 BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
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 HireGoToken is MintableToken, BurnableToken {
string public constant name = "HireGo";
string public constant symbol = "HGO";
uint32 public constant decimals = 18;
function HireGoToken() public {
totalSupply = 100000000E18; //100m
balances[owner] = totalSupply; // Add all tokens to issuer balance (crowdsale in this case)
}
}
contract HireGoCrowdsale is Ownable {
using SafeMath for uint;
HireGoToken public token = new HireGoToken();
uint totalSupply = token.totalSupply();
bool public isRefundAllowed;
uint public icoStartTime;
uint public icoEndTime;
uint public totalWeiRaised;
uint public weiRaised;
uint public hardCap; // amount of ETH collected, which marks end of crowd sale
uint public tokensDistributed; // amount of bought tokens
uint public foundersTokensUnlockTime;
uint internal baseBonus1 = 135;
uint internal baseBonus2 = 130;
uint internal baseBonus3 = 125;
uint internal baseBonus4 = 115;
uint public manualBonus;
uint public waveCap1;
uint public waveCap2;
uint public waveCap3;
uint public waveCap4;
uint public rate; // how many token units a buyer gets per wei
uint private icoMinPurchase; // In ETH
address[] public investors_number;
address private wallet; // address where funds are collected
mapping (address => uint) public orderedTokens;
mapping (address => uint) contributors;
event FundsWithdrawn(address _who, uint256 _amount);
modifier hardCapNotReached() {
require(totalWeiRaised < hardCap);
_;
}
modifier crowdsaleEnded() {
require(now > icoEndTime);
_;
}
modifier foundersTokensUnlocked() {
require(now > foundersTokensUnlockTime);
_;
}
modifier crowdsaleInProgress() {
bool withinPeriod = (now >= icoStartTime && now <= icoEndTime);
require(withinPeriod);
_;
}
function HireGoCrowdsale(uint _icoStartTime, uint _icoEndTime, address _wallet) public {
require (_icoStartTime > now &&
_icoEndTime > _icoStartTime);
icoStartTime = _icoStartTime;
icoEndTime = _icoEndTime;
foundersTokensUnlockTime = icoEndTime.add(180 days);
wallet = _wallet;
rate = 250 szabo; // wei per 1 token (0.00025ETH)
hardCap = 11836 ether;
icoMinPurchase = 50 finney; // 0.05 ETH
isRefundAllowed = false;
waveCap1 = 2777 ether;
waveCap2 = waveCap1.add(2884 ether);
waveCap3 = waveCap2.add(4000 ether);
waveCap4 = waveCap3.add(2174 ether);
}
// fallback function can be used to buy tokens
function() public payable {
buyTokens();
}
// low level token purchase function
function buyTokens() public payable crowdsaleInProgress hardCapNotReached {
require(msg.value > 0);
// check if the buyer exceeded the funding goal
calculatePurchaseAndBonuses(msg.sender, msg.value);
}
// Returns number of investors
function getInvestorCount() public view returns (uint) {
return investors_number.length;
}
function toggleRefunds() public onlyOwner {
isRefundAllowed = true;
}
// Sends ordered tokens to investors after ICO end if soft cap is reached
// tokens can be send only if ico has ended
function sendOrderedTokens() public onlyOwner crowdsaleEnded {
address investor;
uint tokensCount;
for(uint i = 0; i < investors_number.length; i++) {
investor = investors_number[i];
tokensCount = orderedTokens[investor];
assert(tokensCount > 0);
orderedTokens[investor] = 0;
token.transfer(investor, tokensCount);
}
}
// Owner can send back collected ETH if soft cap is not reached or KYC is not passed
// WARNING: crowdsale contract should have all received funds to return them.
// If you have already withdrawn them, send them back to crowdsale contract
function refundInvestors() public onlyOwner {
require(now >= icoEndTime);
require(isRefundAllowed);
require(msg.sender.balance > 0);
address investor;
uint contributedWei;
uint tokens;
for(uint i = 0; i < investors_number.length; i++) {
investor = investors_number[i];
contributedWei = contributors[investor];
tokens = orderedTokens[investor];
if(contributedWei > 0) {
totalWeiRaised = totalWeiRaised.sub(contributedWei);
weiRaised = weiRaised.sub(contributedWei);
if(weiRaised<0){
weiRaised = 0;
}
contributors[investor] = 0;
orderedTokens[investor] = 0;
tokensDistributed = tokensDistributed.sub(tokens);
investor.transfer(contributedWei); // return funds back to contributor
}
}
}
// Owner of contract can withdraw collected ETH by calling this function
function withdraw() public onlyOwner {
uint to_send = weiRaised;
weiRaised = 0;
FundsWithdrawn(msg.sender, to_send);
wallet.transfer(to_send);
}
function burnUnsold() public onlyOwner crowdsaleEnded {
uint tokensLeft = totalSupply.sub(tokensDistributed);
token.burn(tokensLeft);
}
function finishIco() public onlyOwner {
icoEndTime = now;
}
function distribute_for_founders() public onlyOwner foundersTokensUnlocked {
uint to_send = 40000000E18; //40m
checkAndMint(to_send);
token.transfer(wallet, to_send);
}
function transferOwnershipToken(address _to) public onlyOwner {
token.transferOwnership(_to);
}
// Calculates purchase conditions and token bonuses
function calculatePurchaseAndBonuses(address _beneficiary, uint _weiAmount) internal {
if (now >= icoStartTime && now < icoEndTime) require(_weiAmount >= icoMinPurchase);
uint cleanWei; // amount of wei to use for purchase excluding change and hardcap overflows
uint change;
uint _tokens;
//check for hardcap overflow
if (_weiAmount.add(totalWeiRaised) > hardCap) {
cleanWei = hardCap.sub(totalWeiRaised);
change = _weiAmount.sub(cleanWei);
}
else cleanWei = _weiAmount;
assert(cleanWei > 4); // 4 wei is a price of minimal fracture of token
_tokens = cleanWei.div(rate).mul(1 ether);
if (contributors[_beneficiary] == 0) investors_number.push(_beneficiary);
_tokens = calculateBonus(_tokens);
checkAndMint(_tokens);
contributors[_beneficiary] = contributors[_beneficiary].add(cleanWei);
weiRaised = weiRaised.add(cleanWei);
totalWeiRaised = totalWeiRaised.add(cleanWei);
tokensDistributed = tokensDistributed.add(_tokens);
orderedTokens[_beneficiary] = orderedTokens[_beneficiary].add(_tokens);
if (change > 0) _beneficiary.transfer(change);
}
// Calculates bonuses based on current stage
function calculateBonus(uint _baseAmount) internal returns (uint) {
require(_baseAmount > 0);
if (now >= icoStartTime && now < icoEndTime) {
return calculateBonusIco(_baseAmount);
}
else return _baseAmount;
}
// Calculates bonuses, specific for the ICO
// Contains date and volume based bonuses
function calculateBonusIco(uint _baseAmount) internal returns(uint) {
if(totalWeiRaised < waveCap1) {
return _baseAmount.mul(baseBonus1).div(100);
}
else if(totalWeiRaised >= waveCap1 && totalWeiRaised < waveCap2) {
return _baseAmount.mul(baseBonus2).div(100);
}
else if(totalWeiRaised >= waveCap2 && totalWeiRaised < waveCap3) {
return _baseAmount.mul(baseBonus3).div(100);
}
else if(totalWeiRaised >= waveCap3 && totalWeiRaised < waveCap4) {
return _baseAmount.mul(baseBonus4).div(100);
}
else {
// No bonus
return _baseAmount;
}
}
// If there are not enough tokens, mint missing tokens
function checkAndMint(uint _amount) internal {
uint required = tokensDistributed.add(_amount);
if(required > totalSupply) token.mint(this, required.sub(totalSupply));
}
}
| 147,280 | 12,933 |
a64e4d145ddfe018313f4e86e9d061d9a28a49238b172cca07db452e793d477a
| 23,987 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/fa/fa95c58deb987dbcdeb78ff0cefdc8897c616380_liqlocker.sol
| 2,916 | 11,405 |
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context{
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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 SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
'SafeBEP20: approve from non-zero to non-zero allowance');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
'SafeBEP20: decreased allowance below zero');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
contract liqlocker is Ownable{
using SafeBEP20 for IBEP20;
address public mine;
function payoutToken(address _token, uint256 _amount) public onlyOwner{
IBEP20(_token).transfer(msg.sender, _amount);
}
function deposit(IBEP20 _token, uint256 _amount) public onlyOwner {
IBEP20(_token).transferFrom(msg.sender, address(this), _amount);
mine = msg.sender;
}
function withdraw(IBEP20 _token, uint256 _amount) public onlyOwner{
IBEP20(_token).transfer(msg.sender, _amount);
}
}
| 324,629 | 12,934 |
0d75a2393fbe8d1862baf9c7e36fd96f91e6d7aca7cb0bd298e4ca6d583f1383
| 40,367 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fc/fc84aa4a1d909f2a9f73e7324a24586e28a00fe9_KANDYSale.sol
| 4,960 | 19,311 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract KANDYSale is Ownable {
using SafeERC20 for ERC20;
using Address for address;
uint constant MIMdecimals = 10 ** 18;
uint constant KANDYdecimals = 10 ** 9;
uint public constant MAX_SOLD = 200000 * KANDYdecimals;
uint public constant PRICE = 5 * MIMdecimals / KANDYdecimals ;
uint public constant MIN_PRESALE_PER_ACCOUNT = 200 * KANDYdecimals;
uint public constant MAX_PRESALE_PER_ACCOUNT = 400 * KANDYdecimals;
address public dev;
ERC20 MIM;
uint public sold;
address public KANDY;
bool public canClaim;
bool public privateSale;
mapping(address => uint256) public invested;
mapping(address => bool) public claimed;
mapping(address => bool) public approvedBuyers;
mapping(address => bool) public blacklisted;
constructor() {
MIM = ERC20(0x130966628846BFd36ff31a822705796e8cb8C18D);
dev = 0x6fFdc09f0e8B4F194301C32113345a1Bea5DBF38;
sold = 0;
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function _approveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = true;
return approvedBuyers[newBuyer_];
}
function approveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _approveBuyer(newBuyer_);
}
function approveBuyers(address[] calldata newBuyers_) external onlyOwner() returns (uint256) {
for(uint256 iteration_ = 0; newBuyers_.length > iteration_; iteration_++) {
_approveBuyer(newBuyers_[iteration_]);
}
return newBuyers_.length;
}
function _deapproveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = false;
return approvedBuyers[newBuyer_];
}
function deapproveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _deapproveBuyer(newBuyer_);
}
function _blacklistBuyer(address badBuyer_) internal onlyOwner() returns (bool) {
blacklisted[badBuyer_] = true;
return blacklisted[badBuyer_];
}
function blacklistBuyer(address badBuyer_) external onlyOwner() returns (bool) {
return _blacklistBuyer(badBuyer_);
}
function blacklistBuyers (address[] calldata badBuyers_) external onlyOwner() returns (uint256) {
for (uint256 iteration_ = 0; badBuyers_.length > iteration_; iteration_++) {
_blacklistBuyer(badBuyers_[iteration_]);
}
return badBuyers_.length;
}
function amountBuyable(address buyer) public view returns (uint256) {
uint256 max;
if (approvedBuyers[buyer] && privateSale) {
max = MAX_PRESALE_PER_ACCOUNT;
}
return max - invested[buyer];
}
function buyKANDY(uint256 amount) public onlyEOA {
require(sold < MAX_SOLD, "sold out");
require(sold + amount < MAX_SOLD, "not enough remaining");
require(amount <= amountBuyable(msg.sender), "amount exceeds buyable amount");
require(amount + invested[msg.sender] >= MIN_PRESALE_PER_ACCOUNT, "amount is not sufficient");
MIM.safeTransferFrom(msg.sender, address(this), amount * PRICE);
invested[msg.sender] += amount;
sold += amount;
}
// set KANDY token address and activate claiming
function setClaimingActive(address kandy) public {
require(msg.sender == dev, "!dev");
KANDY = kandy;
canClaim = true;
}
// claim KANDY allocation based on old + new invested amounts
function claimKANDY() public onlyEOA {
require(canClaim, "cannot claim yet");
require(!claimed[msg.sender], "already claimed");
require(!blacklisted[msg.sender], "blacklisted");
if (invested[msg.sender] > 0) {
ERC20(KANDY).transfer(msg.sender, invested[msg.sender]);
}
claimed[msg.sender] = true;
}
// token withdrawal by dev
function withdraw(address _token) public {
require(msg.sender == dev, "!dev");
uint b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev,b);
}
// manual activation of whitelisted sales
function activatePrivateSale() public {
require(msg.sender == dev, "!dev");
privateSale = true;
}
// manual deactivation of whitelisted sales
function deactivatePrivateSale() public {
require(msg.sender == dev, "!dev");
privateSale = false;
}
function setSold(uint _soldAmount) public onlyOwner {
sold = _soldAmount;
}
}
| 91,912 | 12,935 |
c21756ac1a824a6bdeb103475673cf5d9d12ee6f8e5947d454331f3156735a47
| 17,257 |
.sol
|
Solidity
| false |
156519749
|
LayerXcom/stark-sol
|
ebbf5f160ff934c513f4a458e91f699a0160395a
|
contracts/BytesLib.sol
| 3,813 | 16,197 |
pragma solidity >=0.4.24 <0.6.0;
library BytesLib {
function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory) {
bytes memory tempBytes;
assembly {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// Store the length of the first bytes array at the beginning of
// the memory for tempBytes.
let length := mload(_preBytes)
mstore(tempBytes, length)
// Maintain a memory counter for the current write location in the
// temp bytes array by adding the 32 bytes for the array length to
// the starting location.
let mc := add(tempBytes, 0x20)
// Stop copying when the memory counter reaches the length of the
// first bytes array.
let end := add(mc, length)
for {
// Initialize a copy counter to the start of the _preBytes data,
// 32 bytes into its memory.
let cc := add(_preBytes, 0x20)
} lt(mc, end) {
// Increase both counters by 32 bytes each iteration.
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// Write the _preBytes data into the tempBytes memory 32 bytes
// at a time.
mstore(mc, mload(cc))
}
// Add the length of _postBytes to the current length of tempBytes
// and store it as the new length in the first 32 bytes of the
// tempBytes memory.
length := mload(_postBytes)
mstore(tempBytes, add(length, mload(tempBytes)))
// Move the memory counter back from a multiple of 0x20 to the
// actual end of the _preBytes data.
mc := end
// Stop copying when the memory counter reaches the new combined
// length of the arrays.
end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
// Update the free-memory pointer by padding our last write location
// to 32 bytes: add 31 bytes to the end of tempBytes to move to the
// next 32 byte block, then round down to the nearest multiple of
// 32. If the sum of the length of the two arrays is zero then add
// one before rounding down to leave a blank 32 bytes (the length block with 0).
mstore(0x40, and(add(add(end, iszero(add(length, mload(_preBytes)))), 31),
not(31) // Round down to the nearest 32 bytes.))
}
return tempBytes;
}
function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
assembly {
// Read the first 32 bytes of _preBytes storage, which is the length
// of the array. (We don't need to use the offset into the slot
// because arrays use the entire slot.)
let fslot := sload(_preBytes_slot)
// Arrays of 31 bytes or less have an even value in their slot,
// while longer arrays have an odd value. The actual length is
// the slot divided by two for odd values, and the lowest order
// byte divided by two for even values.
// If the slot is even, bitwise and the slot with 255 and divide by
// two to get the length. If the slot is odd, bitwise and the slot
// with -1 and divide by two.
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
let newlength := add(slength, mlength)
// slength can contain both the length and contents of the array
// if length < 32 bytes so let's prepare for that
switch add(lt(slength, 32), lt(newlength, 32))
case 2 {
// Since the new array still fits in the slot, we just need to
// update the contents of the slot.
// uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
sstore(_preBytes_slot,
// all the modifications to the slot are inside this
// next block
add(// we can just add to the slot contents because the
// bytes we want to change are the LSBs
fslot,
add(mul(div(// load the bytes from memory
mload(add(_postBytes, 0x20)),
// zero all bytes to the right
exp(0x100, sub(32, mlength))),
// and now shift left the number of bytes to
// leave space for the length in the slot
exp(0x100, sub(32, newlength))),
// increase length by the double of the memory
// bytes length
mul(mlength, 2))))
}
case 1 {
// The stored value fits in the slot, but the combined value
// will exceed it.
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
// save new length
sstore(_preBytes_slot, add(mul(newlength, 2), 1))
// The contents of the _postBytes array start 32 bytes into
// the structure. Our first read should obtain the `submod`
// bytes that can fit into the unused space in the last word
// of the stored array. To get this, we read 32 bytes starting
// from `submod`, so the data we read overlaps with the array
// contents by `submod` bytes. Masking the lowest-order
// `submod` bytes allows us to add that value directly to the
// stored value.
let submod := sub(32, slength)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(sc,
add(and(fslot,
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00),
and(mload(mc), mask)))
for {
mc := add(mc, 0x20)
sc := add(sc, 1)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
default {
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
// Start copying to the last used word of the stored array.
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
// save new length
sstore(_preBytes_slot, add(mul(newlength, 2), 1))
// Copy over the first `submod` bytes of the new data as in
// case 1 above.
let slengthmod := mod(slength, 32)
let mlengthmod := mod(mlength, 32)
let submod := sub(32, slengthmod)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(sc, add(sload(sc), and(mload(mc), mask)))
for {
sc := add(sc, 1)
mc := add(mc, 0x20)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
}
}
function slice(bytes memory _bytes, uint _start, uint _length) internal pure returns (bytes memory) {
require(_bytes.length >= (_start + _length));
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
let lengthmod := and(_length, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, _length)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, _length)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
function toAddress(bytes memory _bytes, uint _start) internal pure returns (address) {
require(_bytes.length >= (_start + 20));
address tempAddress;
assembly {
tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
}
return tempAddress;
}
function toUint(bytes memory _bytes, uint _start) internal pure returns (uint256) {
require(_bytes.length >= (_start + 4));
uint256 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x04), _start))
}
return tempUint;
}
function toBytes32(bytes memory _bytes, uint _start) internal pure returns (bytes32) {
require(_bytes.length >= (_start + 32));
bytes32 tempBytes32;
assembly {
tempBytes32 := mload(add(add(_bytes, 0x20), _start))
}
return tempBytes32;
}
function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
bool success = true;
assembly {
let length := mload(_preBytes)
// if lengths don't match the arrays are not equal
switch eq(length, mload(_postBytes))
case 1 {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
let mc := add(_preBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
// the next line is the loop condition:
// while(uint(mc < end) + cb == 2)
} eq(add(lt(mc, end), cb), 2) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// if any of these checks fails then arrays are not equal
if iszero(eq(mload(mc), mload(cc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
bool success = true;
assembly {
// we know _preBytes_offset is 0
let fslot := sload(_preBytes_slot)
// Decode the length of the stored array like in concatStorage().
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
// if lengths don't match the arrays are not equal
switch eq(slength, mlength)
case 1 {
// slength can contain both the length and contents of the array
// if length < 32 bytes so let's prepare for that
if iszero(iszero(slength)) {
switch lt(slength, 32)
case 1 {
// blank the last byte which is the length
fslot := mul(div(fslot, 0x100), 0x100)
if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
// unsuccess:
success := 0
}
}
default {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
let sc := keccak256(0x0, 0x20)
let mc := add(_postBytes, 0x20)
let end := add(mc, mlength)
// the next line is the loop condition:
// while(uint(mc < end) + cb == 2)
for {} eq(add(lt(mc, end), cb), 2) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
if iszero(eq(sload(sc), mload(mc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function toBytes32FromUint(uint256 x) internal pure returns (bytes32) { // TODO: Fix can be used
bytes32 b;
assembly { mstore(add(b, 32), x) }
return b;
}
function toBytes(uint256 x) internal pure returns (bytes memory) {
bytes memory b = new bytes(32);
assembly { mstore(add(b, 32), x) }
return b;
}
}
| 22,176 | 12,936 |
a729b7ecce08f933611321e3f4e72c9035f0b5a436be57403a167d7c4cddaefb
| 12,642 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x44cdebe3093919c94ddba3d77dcef8f0836a09d1.sol
| 3,258 | 12,185 |
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 IERC20 {
function balanceOf(address _to) public constant returns (uint256);
function transfer(address to, uint256 value) public;
function transferFrom(address from, address to, uint256 value) public;
function approve(address spender, uint256 value) public;
function allowance(address owner, address spender) public constant returns(uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is IERC20{
using SafeMath for uint256;
// Balances for each account
mapping (address => uint256) balances;
// Owner of account approves the transfer of an amount to another account
mapping (address => mapping(address => uint256)) allowed;
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balanace the particular account
function balanceOf(address _to) public constant returns (uint256) {
return balances[_to];
}
// @notice send `value` token to `to` from `msg.sender`
// @param to The address of the recipient
// @param value The amount of token to be transferred
// @return the transaction address and send the event as Transfer
function transfer(address to, uint256 value) public {
require (balances[msg.sender] >= value && value > 0);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
}
// @notice send `value` token to `to` from `from`
// @param from The address of the sender
// @param to The address of the recipient
// @param value The amount of token to be transferred
// @return the transaction address and send the event as Transfer
function transferFrom(address from, address to, uint256 value) public {
require (allowed[from][msg.sender] >= value && balances[from] >= value && value > 0);
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
Transfer(from, to, value);
}
// Allow spender to withdraw from your account, multiple times, up to the value amount.
// If this function is called again it overwrites the current allowance with value.
// @param spender The address of the sender
// @param value The amount to be approved
// @return the transaction address and send the event as Approval
function approve(address spender, uint256 value) public {
require (balances[msg.sender] >= value && value > 0);
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
}
// Check the allowed value for the spender to withdraw from owner
// @param owner The address of the owner
// @param spender The address of the spender
// @return the amount which spender is still allowed to withdraw from owner
function allowance(address _owner, address spender) public constant returns (uint256) {
return allowed[_owner][spender];
}
}
contract TLC is StandardToken {
using SafeMath for uint256;
string public constant name = "Toplancer";
string public constant symbol = "TLC";
uint256 public constant decimals = 18;
uint256 public constant totalSupply = 400000000e18;
}
contract TLCMarketCrowdsale is TLC {
uint256 public minContribAmount = 0.1 ether; // 0.1 ether
uint256 public presaleCap = 20000000e18; // 5%
uint256 public soldTokenInPresale;
uint256 public publicSaleCap = 320000000e18; // 80%
uint256 public soldTokenInPublicsale;
uint256 public distributionSupply = 60000000e18; // 15%
uint256 public softCap = 5000 ether;
uint256 public hardCap = 60000 ether;
// amount of raised money in wei
uint256 public weiRaised = 0;
// Wallet Address of Token
address public multisig;
// Owner of Token
address public owner;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// how many token units a buyer gets per wei
uint256 public rate = 3500 ; // 1 ether = 3500 TLC
// How much ETH each address has invested to this publicsale
mapping (address => uint256) public investedAmountOf;
// How many distinct addresses have invested
uint256 public investorCount;
// fund raised during public sale
uint256 public fundRaisedDuringPublicSale = 0;
// How much wei we have returned back to the contract after a failed crowdfund.
uint256 public loadedRefund = 0;
// How much wei we have given back to investors.
uint256 public weiRefunded = 0;
enum Stage {PRESALE, PUBLICSALE, SUCCESS, FAILURE, REFUNDING, CLOSED}
Stage public stage;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
// Refund was processed for a contributor
event Refund(address investor, uint256 weiAmount);
function TLCMarketCrowdsale(uint256 _startTime, uint256 _endTime, address _wallet) {
require(_endTime >= _startTime && _wallet != 0x0);
startTime = _startTime;
endTime = _endTime;
multisig = _wallet;
owner=msg.sender;
balances[multisig] = totalSupply;
stage = Stage.PRESALE;
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
uint256 timebasedBonus = tokens.mul(getTimebasedBonusRate()).div(100);
tokens = tokens.add(timebasedBonus);
forwardFunds();
if (stage == Stage.PRESALE) {
assert (soldTokenInPresale + tokens <= presaleCap);
soldTokenInPresale = soldTokenInPresale.add(tokens);
} else {
assert (soldTokenInPublicsale + tokens <= publicSaleCap);
if(investedAmountOf[beneficiary] == 0) {
// A new investor
investorCount++;
}
// Update investor
investedAmountOf[beneficiary] = investedAmountOf[beneficiary].add(weiAmount);
fundRaisedDuringPublicSale = fundRaisedDuringPublicSale.add(weiAmount);
soldTokenInPublicsale = soldTokenInPublicsale.add(tokens);
}
balances[multisig] = balances[multisig].sub(tokens);
balances[beneficiary] = balances[beneficiary].add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
multisig.transfer(msg.value);
}
// Payable method
// @notice Anyone can buy the tokens on tokensale by paying ether
function () public payable {
buyTokens(msg.sender);
}
// modifier to allow only owner has full control on the function
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier isRefunding {
require (stage == Stage.REFUNDING);
_;
}
modifier isFailure {
require (stage == Stage.FAILURE);
_;
}
// @return true if crowdsale current lot event has ended
function hasEnded() public constant returns (bool) {
return getNow() > endTime;
}
// @return current time
function getNow() public constant returns (uint256) {
return (now * 1000);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = getNow() >= startTime && getNow() <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool minContribution = minContribAmount <= msg.value;
return withinPeriod && nonZeroPurchase && minContribution;
}
// Get the time-based bonus rate
function getTimebasedBonusRate() internal constant returns (uint256) {
uint256 bonusRate = 0;
if (stage == Stage.PRESALE) {
bonusRate = 50;
} else {
uint256 nowTime = getNow();
uint256 bonusFirstWeek = startTime + (7 days * 1000);
uint256 bonusSecondWeek = bonusFirstWeek + (7 days * 1000);
uint256 bonusThirdWeek = bonusSecondWeek + (7 days * 1000);
uint256 bonusFourthWeek = bonusThirdWeek + (7 days * 1000);
if (nowTime <= bonusFirstWeek) {
bonusRate = 25;
} else if (nowTime <= bonusSecondWeek) {
bonusRate = 20;
} else if (nowTime <= bonusThirdWeek) {
bonusRate = 10;
} else if (nowTime <= bonusFourthWeek) {
bonusRate = 5;
}
}
return bonusRate;
}
// Start public sale
function startPublicsale(uint256 _startTime, uint256 _endTime, uint256 _tokenPrice) public onlyOwner {
require(hasEnded() && stage == Stage.PRESALE && _endTime >= _startTime && _tokenPrice > 0);
stage = Stage.PUBLICSALE;
startTime = _startTime;
endTime = _endTime;
rate = _tokenPrice;
}
// @return true if the crowdsale has raised enough money to be successful.
function isMaximumGoalReached() public constant returns (bool reached) {
return weiRaised >= hardCap;
}
// Validate and update the crowdsale stage
function updateICOStatus() public onlyOwner {
require(hasEnded() && stage == Stage.PUBLICSALE);
if (hasEnded() && weiRaised >= softCap) {
stage = Stage.SUCCESS;
} else if (hasEnded()) {
stage = Stage.FAILURE;
}
}
function loadRefund() public payable isFailure{
require(msg.value != 0);
loadedRefund = loadedRefund.add(msg.value);
if (loadedRefund <= fundRaisedDuringPublicSale) {
stage = Stage.REFUNDING;
}
}
// Investors can claim refund.
function refund() public isRefunding {
uint256 weiValue = investedAmountOf[msg.sender];
require (weiValue != 0);
investedAmountOf[msg.sender] = 0;
balances[msg.sender] = 0;
weiRefunded = weiRefunded.add(weiValue);
Refund(msg.sender, weiValue);
msg.sender.transfer(weiValue);
if (weiRefunded <= fundRaisedDuringPublicSale) {
stage = Stage.CLOSED;
}
}
// Set/change Multi-signature wallet address
function changeMultiSignatureWallet (address _multisig)public onlyOwner{
multisig = _multisig;
}
// Change Minimum contribution
function changeMinContribution(uint256 _minContribAmount)public onlyOwner {
minContribAmount = _minContribAmount;
}
//Change Presale Publicsale end time
function changeEndTime(uint256 _endTime) public onlyOwner {
require(endTime > startTime);
endTime = _endTime;
}
// Token distribution to Founder, Key Employee Allocation
// _founderAndTeamCap = 10000000e18; 10%
function sendFounderAndTeamToken(address to, uint256 value) public onlyOwner{
require (to != 0x0 && value > 0 && distributionSupply >= value);
balances[multisig] = balances[multisig].sub(value);
balances[to] = balances[to].add(value);
distributionSupply = distributionSupply.sub(value);
Transfer(multisig, to, value);
}
}
| 203,927 | 12,937 |
a4025425835ba26744f7fb7bcda5a48ff7a6a3cc359056998b083fe29c03095d
| 27,358 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/97/9714e3D12E83657D22Ff9BE1B7C44d76C20c40c1_KandyStaking.sol
| 4,190 | 16,927 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function 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 KandyStaking 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;
}
}
| 107,827 | 12,938 |
9803dfd2500856e1160039f2dfa310be2b9ecc26578f161df94ee5f3c0444c57
| 23,211 |
.sol
|
Solidity
| false |
300214684
|
sohkai/erc20-battery
|
64bc0072060bceccc357add47ed95f00e50061f6
|
contracts/5/Uni.sol
| 4,143 | 15,670 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Uni {
/// @notice EIP-20 token name for this token
string public constant name = "Uniswap";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "UNI";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 1_000_000_000e18; // 1 billion Uni
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
require(mintingAllowedAfter_ >= block.timestamp, "Uni::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "Uni::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "Uni::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "Uni::mint: minting not allowed yet");
require(dst != address(0), "Uni::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "Uni::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "Uni::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "Uni::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "Uni::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Uni::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 {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Uni::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), "Uni::permit: invalid signature");
require(signatory == owner, "Uni::permit: unauthorized");
require(now <= deadline, "Uni::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Uni::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Uni::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Uni::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Uni::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Uni::delegateBySig: invalid nonce");
require(now <= expiry, "Uni::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Uni::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Uni::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Uni::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Uni::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Uni::_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, "Uni::_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, "Uni::_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, "Uni::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 175,108 | 12,939 |
2f10d1006b01bcaa22426ef68b04976294460d0e8f347e38f3e1861a3316308a
| 15,749 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFFm8svPq9Gw2jADLcGtaJbqaJAUptYKko_TronSunV2.sol
| 4,134 | 14,953 |
//SourceUnit: Tronsunv2.sol
pragma solidity 0.5.9;
contract TronSunV2 {
using SafeMath for uint256;
// Operating costs
uint256 constant public MARKETING_FEE = 40;
uint256 constant public ADMIN_FEE = 40;
uint256 constant public DEV_FEE = 90;
uint256 constant public INSURANCE_FEE = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
// Referral percentages
uint8 public constant FIRST_REF = 5;
uint8 public constant SECOND_REF = 3;
uint8 public constant THIRD_REF = 2;
uint8 public constant FOURTH_REF = 1;
uint8 public constant FIFTH_REF = 4;
// Limits
uint256 public constant DEPOSIT_MIN_AMOUNT = 200 trx;
// Before reinvest
uint256 public constant WITHDRAWAL_DEADTIME = 1 days;
// Max ROC days and related MAX ROC (Return of contribution)
uint8 public constant CONTRIBUTION_DAYS = 75;
uint256 public constant CONTRIBUTION_PERC = 300;
// Operating addresses
address payable owner; // Smart Contract Owner (who deploys)
address payable public mkar; // Marketing manager
address payable public adar; // Project manager
address payable public dvar; // Developer
address payable public insurancer; //insurance
uint256 total_investors;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
uint8[] referral_bonuses;
struct PlayerDeposit {
uint256 amount;
uint256 totalWithdraw;
uint256 time;
}
struct PlayerWitdraw{
uint256 time;
uint256 amount;
}
struct Player {
address referral;
uint256 dividends;
uint256 referral_bonus;
uint256 last_payout;
uint256 last_withdrawal;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
PlayerWitdraw[] withdrawals;
mapping(uint8 => uint256) referrals_per_level;
}
mapping(address => Player) internal players;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event Reinvest(address indexed addr, uint256 amount);
event ReferralPayout(address indexed addr, uint256 amount, uint8 level);
constructor(address payable marketingAddr, address payable adminAddr, address payable devAddr, address payable insurAddr) public {
require(!isContract(marketingAddr) && !isContract(adminAddr) && !isContract(devAddr));
mkar = marketingAddr;
adar = adminAddr;
dvar = devAddr;
insurancer = insurAddr;
owner = msg.sender;
// Add referral bonuses (max 8 levels) - We use 5 levels
referral_bonuses.push(10 * FIRST_REF);
referral_bonuses.push(10 * SECOND_REF);
referral_bonuses.push(10 * THIRD_REF);
referral_bonuses.push(10 * FOURTH_REF);
referral_bonuses.push(10 * FIFTH_REF);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function deposit(address _referral) external payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(!isContract(_referral));
require(msg.value >= 1e8, "Zero amount");
require(msg.value >= DEPOSIT_MIN_AMOUNT, "Deposit is below minimum amount");
Player storage player = players[msg.sender];
require(player.deposits.length < 10000000, "Max 10000000 deposits per address");
// Check and set referral
_setReferral(msg.sender, _referral);
// Create deposit
player.deposits.push(PlayerDeposit({
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
if(player.total_contributed == 0x0){
total_investors += 1;
}
player.total_contributed += msg.value;
total_contributed += msg.value;
// Generate referral rewards
_referralPayout(msg.sender, msg.value);
// Pay fees
_feesPayout(msg.value);
emit Deposit(msg.sender, msg.value);
}
function _setReferral(address _addr, address _referral) private {
// Set referral if the user is a new user
if(players[_addr].referral == address(0)) {
// If referral is a registered user, set it as ref, otherwise set adar as ref
if(players[_referral].total_contributed > 0) {
players[_addr].referral = _referral;
} else {
players[_addr].referral = adar;
}
// Update the referral counters
for(uint8 i = 0; i < referral_bonuses.length; i++) {
players[_referral].referrals_per_level[i]++;
_referral = players[_referral].referral;
if(_referral == address(0)) break;
}
}
}
function _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
Player storage upline_player = players[ref];
// Generate upline rewards
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus = _amount * referral_bonuses[i] / 1000;
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
total_referral_bonus += bonus;
emit ReferralPayout(ref, bonus, (i+1));
ref = players[ref].referral;
}
}
function _feesPayout(uint256 _amount) private {
// Send fees if there is enough balance
if (address(this).balance > _feesTotal(_amount)) {
mkar.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
adar.transfer(_amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER));
dvar.transfer(_amount.mul(DEV_FEE).div(PERCENTS_DIVIDER));
insurancer.transfer(_amount.mul(INSURANCE_FEE).div(PERCENTS_DIVIDER));
}
}
// Total fees amount
function _feesTotal(uint256 _amount) private view returns(uint256 _fees_tot) {
_fees_tot = _amount.mul(MARKETING_FEE+ADMIN_FEE+DEV_FEE+INSURANCE_FEE).div(PERCENTS_DIVIDER);
}
function autoReinvest(uint256 _amount) private returns (bool) {
Player storage player = players[msg.sender];
// Create deposit
player.deposits.push(PlayerDeposit({
amount: _amount,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
player.total_contributed += _amount;
total_contributed += _amount;
// Generate referral rewards
_referralPayout(msg.sender, _amount);
// Pay fees
_feesPayout(_amount);
return true;
}
function withdraw() public {
Player storage player = players[msg.sender];
PlayerDeposit storage first_dep = player.deposits[0];
// Can withdraw once every WITHDRAWAL_DEADTIME days
require(uint256(block.timestamp) > (player.last_withdrawal + WITHDRAWAL_DEADTIME) || (player.withdrawals.length <= 0), "You cannot withdraw during deadtime");
require(address(this).balance > 0, "Cannot withdraw, contract balance is 0");
require(player.deposits.length < 10000000, "Max 10000000 deposits per address");
// Calculate dividends (ROC)
uint256 payout = this.payoutOf(msg.sender);
player.dividends += payout;
// Calculate the amount we should withdraw
uint256 amount_withdrawable = player.dividends + player.referral_bonus;
require(amount_withdrawable > 0, "Zero amount to withdraw");
if (amount_withdrawable > 30000 trx){
// Do Withdraw
uint256 amount_max_for_withdraw = 30000 trx;
if (address(this).balance < amount_max_for_withdraw) {
player.dividends = amount_max_for_withdraw.sub(address(this).balance);
amount_withdrawable = address(this).balance;
} else {
player.dividends = amount_withdrawable - amount_max_for_withdraw;
}
msg.sender.transfer((amount_max_for_withdraw/2));
autoReinvest((amount_max_for_withdraw/2));
// Update player state
player.referral_bonus = 0;
player.total_withdrawn += amount_max_for_withdraw;
total_withdrawn += amount_max_for_withdraw;
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_max_for_withdraw
}));
emit Withdraw(msg.sender, amount_max_for_withdraw);
}
else{
// Do Withdraw
if (address(this).balance < amount_withdrawable) {
player.dividends = amount_withdrawable.sub(address(this).balance);
amount_withdrawable = address(this).balance;
} else {
player.dividends = 0;
}
msg.sender.transfer((amount_withdrawable/2));
autoReinvest((amount_withdrawable/2));
// Update player state
player.referral_bonus = 0;
player.total_withdrawn += amount_withdrawable;
total_withdrawn += amount_withdrawable;
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_withdrawable
}));
emit Withdraw(msg.sender, amount_withdrawable);
}
}
function _updateTotalPayout(address _addr) private {
Player storage player = players[_addr];
// For every deposit calculate the ROC and update the withdrawn part
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
player.deposits[i].totalWithdraw += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
}
function withdrawalsOf(address _addrs) view external returns(uint256 _amount) {
Player storage player = players[_addrs];
// Calculate all the real withdrawn amount (to wallet, not reinvested)
for(uint256 n = 0; n < player.withdrawals.length; n++){
_amount += player.withdrawals[n].amount;
}
return _amount;
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
// For every deposit calculate the ROC
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
value += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
// Total dividends from all deposits
return value;
}
function contractInfo() view external returns(uint256 _total_contributed, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral_bonus) {
return (total_contributed, total_investors, total_withdrawn, total_referral_bonus);
}
function inSurInfo() view external returns(uint256 insurDepo){
return address(insurancer).balance;
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_referral_bonus, uint256 invested, uint256 withdrawn, uint256 referral_bonus, uint256[8] memory referrals, uint256 _last_withdrawal) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
// Calculate number of referrals for each level
for(uint8 i = 0; i < referral_bonuses.length; i++) {
referrals[i] = player.referrals_per_level[i];
}
// Return user information
return (payout + player.dividends + player.referral_bonus,
player.referral_bonus,
player.total_contributed,
player.total_withdrawn,
player.total_referral_bonus,
referrals,
player.last_withdrawal);
}
function contributionsInfo(address _addr) view external returns(uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws) {
Player storage player = players[_addr];
uint256[] memory _endTimes = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _totalWithdraws = new uint256[](player.deposits.length);
// Create arrays with deposits info, each index is related to a deposit
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time + CONTRIBUTION_DAYS * 86400;
}
return (_endTimes,
_amounts,
_totalWithdraws);
}
}
// Libraries used
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 296,041 | 12,940 |
26a90eda643c19137d015de58de6be59136c85debfe41cb1a506cb8b9b5a2251
| 21,449 |
.sol
|
Solidity
| false |
580239440
|
pendle-finance/pendle-core-v2-public
|
42928e2f99bcffdb2417ce26e9dc58d0d7c3fbb3
|
contracts/core/libraries/math/LogExpMath.sol
| 4,627 | 13,760 |
// SPDX-License-Identifier: GPL-3.0-or-later
// permit persons to whom the Software is furnished to do so, subject to the following conditions:
// Software.
pragma solidity 0.8.17;
library LogExpMath {
// two numbers, and multiply by ONE when dividing them.
// All arguments and return values are 18 decimal fixed point numbers.
int256 constant ONE_18 = 1e18;
// case of ln36, 36 decimals.
int256 constant ONE_20 = 1e20;
int256 constant ONE_36 = 1e36;
// The domain of natural exponentiation is bound by the word size and number of decimals used.
//
// Because internally the result will be stored using 20 decimals, the largest possible result is
// The smallest possible result is 10^(-18), which makes largest negative argument
// ln(10^(-18)) = -41.446531673892822312.
// We use 130.0 and -41.0 to have some safety margin.
int256 constant MAX_NATURAL_EXPONENT = 130e18;
int256 constant MIN_NATURAL_EXPONENT = -41e18;
// 256 bit integer.
int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17;
int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17;
uint256 constant MILD_EXPONENT_BOUND = 2 ** 254 / uint256(ONE_20);
// 18 decimal constants
int256 constant x0 = 128000000000000000000; // 27
int256 constant a0 = 38877084059945950922200000000000000000000000000000000000; // e(x0) (no decimals)
int256 constant x1 = 64000000000000000000; // 26
int256 constant a1 = 6235149080811616882910000000; // e(x1) (no decimals)
// 20 decimal constants
int256 constant x2 = 3200000000000000000000; // 25
int256 constant a2 = 7896296018268069516100000000000000; // e(x2)
int256 constant x3 = 1600000000000000000000; // 24
int256 constant a3 = 888611052050787263676000000; // e(x3)
int256 constant x4 = 800000000000000000000; // 23
int256 constant a4 = 298095798704172827474000; // e(x4)
int256 constant x5 = 400000000000000000000; // 22
int256 constant a5 = 5459815003314423907810; // e(x5)
int256 constant x6 = 200000000000000000000; // 21
int256 constant a6 = 738905609893065022723; // e(x6)
int256 constant x7 = 100000000000000000000; // 20
int256 constant a7 = 271828182845904523536; // e(x7)
int256 constant x8 = 50000000000000000000; // 2-1
int256 constant a8 = 164872127070012814685; // e(x8)
int256 constant x9 = 25000000000000000000; // 2-2
int256 constant a9 = 128402541668774148407; // e(x9)
int256 constant x10 = 12500000000000000000; // 2-3
int256 constant a10 = 113314845306682631683; // e(x10)
int256 constant x11 = 6250000000000000000; // 2-4
int256 constant a11 = 106449445891785942956; // e(x11)
function exp(int256 x) internal pure returns (int256) {
unchecked {
require(x >= MIN_NATURAL_EXPONENT && x <= MAX_NATURAL_EXPONENT, "Invalid exponent");
if (x < 0) {
// fits in the signed 256 bit range (as it is larger than MIN_NATURAL_EXPONENT).
// Fixed point division requires multiplying by ONE_18.
return ((ONE_18 * ONE_18) / exp(-x));
}
// because all larger powers are larger than MAX_NATURAL_EXPONENT, and therefore not present in the
// decomposition.
// decomposition, which will be lower than the smallest x_n.
// We mutate x by subtracting x_n, making it the remainder of the decomposition.
// intermediate overflows. Instead we store them as plain integers, with 0 decimals.
// decomposition.
// it and compute the accumulated product.
int256 firstAN;
if (x >= x0) {
x -= x0;
firstAN = a0;
} else if (x >= x1) {
x -= x1;
firstAN = a1;
} else {
firstAN = 1; // One with no decimal places
}
// smaller terms.
x *= 100;
// one. Recall that fixed point multiplication requires dividing by ONE_20.
int256 product = ONE_20;
if (x >= x2) {
x -= x2;
product = (product * a2) / ONE_20;
}
if (x >= x3) {
x -= x3;
product = (product * a3) / ONE_20;
}
if (x >= x4) {
x -= x4;
product = (product * a4) / ONE_20;
}
if (x >= x5) {
x -= x5;
product = (product * a5) / ONE_20;
}
if (x >= x6) {
x -= x6;
product = (product * a6) / ONE_20;
}
if (x >= x7) {
x -= x7;
product = (product * a7) / ONE_20;
}
if (x >= x8) {
x -= x8;
product = (product * a8) / ONE_20;
}
if (x >= x9) {
x -= x9;
product = (product * a9) / ONE_20;
}
// x10 and x11 are unnecessary here since we have high enough precision already.
// expansion for e^x: 1 + x + (x^2 / 2!) + (x^3 / 3!) + ... + (x^n / n!).
int256 seriesSum = ONE_20; // The initial one in the sum, with 20 decimal places.
int256 term; // Each term in the sum, where the nth term is (x^n / n!).
// The first term is simply x.
term = x;
seriesSum += term;
term = ((term * x) / ONE_20) / 2;
seriesSum += term;
term = ((term * x) / ONE_20) / 3;
seriesSum += term;
term = ((term * x) / ONE_20) / 4;
seriesSum += term;
term = ((term * x) / ONE_20) / 5;
seriesSum += term;
term = ((term * x) / ONE_20) / 6;
seriesSum += term;
term = ((term * x) / ONE_20) / 7;
seriesSum += term;
term = ((term * x) / ONE_20) / 8;
seriesSum += term;
term = ((term * x) / ONE_20) / 9;
seriesSum += term;
term = ((term * x) / ONE_20) / 10;
seriesSum += term;
term = ((term * x) / ONE_20) / 11;
seriesSum += term;
term = ((term * x) / ONE_20) / 12;
seriesSum += term;
// 12 Taylor terms are sufficient for 18 decimal precision.
// and then drop two digits to return an 18 decimal value.
return (((product * seriesSum) / ONE_20) * firstAN) / 100;
}
}
function ln(int256 a) internal pure returns (int256) {
unchecked {
// The real natural logarithm is not defined for negative numbers or zero.
require(a > 0, "out of bounds");
if (LN_36_LOWER_BOUND < a && a < LN_36_UPPER_BOUND) {
return _ln_36(a) / ONE_18;
} else {
return _ln(a);
}
}
}
function pow(uint256 x, uint256 y) internal pure returns (uint256) {
unchecked {
if (y == 0) {
// We solve the 0^0 indetermination by making it equal one.
return uint256(ONE_18);
}
if (x == 0) {
return 0;
}
// arrive at that r`esult. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means
// x^y = exp(y * ln(x)).
// The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.
require(x < 2 ** 255, "x out of bounds");
int256 x_int256 = int256(x);
// both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
require(y < MILD_EXPONENT_BOUND, "y out of bounds");
int256 y_int256 = int256(y);
int256 logx_times_y;
if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
int256 ln_36_x = _ln_36(x_int256);
// bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
// multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
// (downscaled) last 18 decimals.
logx_times_y = ((ln_36_x / ONE_18) *
y_int256 +
((ln_36_x % ONE_18) * y_int256) /
ONE_18);
} else {
logx_times_y = _ln(x_int256) * y_int256;
}
logx_times_y /= ONE_18;
// Finally, we compute exp(y * ln(x)) to arrive at x^y
require(MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
"product out of bounds");
return uint256(exp(logx_times_y));
}
}
function _ln(int256 a) private pure returns (int256) {
unchecked {
if (a < ONE_18) {
// Fixed point division requires multiplying by ONE_18.
return (-_ln((ONE_18 * ONE_18) / a));
}
// be represented as 18 fixed point decimal numbers in 256 bits, and are therefore larger than a.
// decomposition, which will be lower than the smallest a_n.
// We mutate a by subtracting a_n, making it the remainder of the decomposition.
// ONE_18 to convert them to fixed point.
// by it and compute the accumulated sum.
int256 sum = 0;
if (a >= a0 * ONE_18) {
a /= a0; // Integer, not fixed point division
sum += x0;
}
if (a >= a1 * ONE_18) {
a /= a1; // Integer, not fixed point division
sum += x1;
}
sum *= 100;
a *= 100;
if (a >= a2) {
a = (a * ONE_20) / a2;
sum += x2;
}
if (a >= a3) {
a = (a * ONE_20) / a3;
sum += x3;
}
if (a >= a4) {
a = (a * ONE_20) / a4;
sum += x4;
}
if (a >= a5) {
a = (a * ONE_20) / a5;
sum += x5;
}
if (a >= a6) {
a = (a * ONE_20) / a6;
sum += x6;
}
if (a >= a7) {
a = (a * ONE_20) / a7;
sum += x7;
}
if (a >= a8) {
a = (a * ONE_20) / a8;
sum += x8;
}
if (a >= a9) {
a = (a * ONE_20) / a9;
sum += x9;
}
if (a >= a10) {
a = (a * ONE_20) / a10;
sum += x10;
}
if (a >= a11) {
a = (a * ONE_20) / a11;
sum += x11;
}
// that converges rapidly for values of `a` close to one - the same one used in ln_36.
// Let z = (a - 1) / (a + 1).
// ln(a) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))
// division by ONE_20.
int256 z = ((a - ONE_20) * ONE_20) / (a + ONE_20);
int256 z_squared = (z * z) / ONE_20;
// num is the numerator of the series: the z^(2 * n + 1) term
int256 num = z;
// seriesSum holds the accumulated sum of each term in the series, starting with the initial z
int256 seriesSum = num;
// In each step, the numerator is multiplied by z^2
num = (num * z_squared) / ONE_20;
seriesSum += num / 3;
num = (num * z_squared) / ONE_20;
seriesSum += num / 5;
num = (num * z_squared) / ONE_20;
seriesSum += num / 7;
num = (num * z_squared) / ONE_20;
seriesSum += num / 9;
num = (num * z_squared) / ONE_20;
seriesSum += num / 11;
// 6 Taylor terms are sufficient for 36 decimal precision.
// Finally, we multiply by 2 (non fixed point) to compute ln(remainder)
seriesSum *= 2;
// value.
return (sum + seriesSum) / 100;
}
}
function _ln_36(int256 x) private pure returns (int256) {
unchecked {
// worthwhile.
// First, we transform x to a 36 digit fixed point value.
x *= ONE_18;
// ln(x) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))
// division by ONE_36.
int256 z = ((x - ONE_36) * ONE_36) / (x + ONE_36);
int256 z_squared = (z * z) / ONE_36;
// num is the numerator of the series: the z^(2 * n + 1) term
int256 num = z;
// seriesSum holds the accumulated sum of each term in the series, starting with the initial z
int256 seriesSum = num;
// In each step, the numerator is multiplied by z^2
num = (num * z_squared) / ONE_36;
seriesSum += num / 3;
num = (num * z_squared) / ONE_36;
seriesSum += num / 5;
num = (num * z_squared) / ONE_36;
seriesSum += num / 7;
num = (num * z_squared) / ONE_36;
seriesSum += num / 9;
num = (num * z_squared) / ONE_36;
seriesSum += num / 11;
num = (num * z_squared) / ONE_36;
seriesSum += num / 13;
num = (num * z_squared) / ONE_36;
seriesSum += num / 15;
// 8 Taylor terms are sufficient for 36 decimal precision.
// All that remains is multiplying by 2 (non fixed point).
return seriesSum * 2;
}
}
}
| 340,290 | 12,941 |
833237d987e08cb48f822782a25872473cac26c956514ebdae888c93c1b9a506
| 16,084 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbec591de75b8699a3ba52f073428822d0bfc0d7e.sol
| 4,241 | 15,081 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.9;
contract WalletEvents {
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// 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
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
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;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xa657491c1e7f16adb39b9b60e87bbb8d93988bc3;
// 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;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// 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;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0xa657491c1e7f16adb39b9b60e87bbb8d93988bc3;
// 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;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
| 180,592 | 12,942 |
5294b3e35a0dddffbf6d191ad1858118c49c171e8a1a38a6d54177f9fe2ab34e
| 16,047 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/36/36cD8Da33aa52EAc96bbb26BE8bb5f2c52748aFC_Distributor.sol
| 3,403 | 13,857 |
// SPDX-License-Identifier: AGPL-3.0-or-later
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));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
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);
}
}
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 ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable Cunoro;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
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 _noro, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_noro != address(0));
Cunoro = IERC20(_noro);
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) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return Cunoro.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external 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 onlyOwner {
require(_recipient != address(0), "IA");
// require(_rewardRate <= 5000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
// require(_target <= 5000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 99,623 | 12,943 |
5aa7a7b398a0bd177070c07964b78e5035423e193064eeec749e49d2b9e694d9
| 25,823 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x71461438f12212e3d059E4e96801b50F3C3E7D77/contract.sol
| 4,441 | 16,394 |
// SPDX-License-Identifier: Unlicensed
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;
}
}
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 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 shibaInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'shibaInu';
string private _symbol = 'SIB';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _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 _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(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);
}
}
| 257,220 | 12,944 |
1001518f7e036d2f515022b300eabd51c06a93a212329f47c63ad967361f0bae
| 14,548 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQ4F8Gr1qRKcMva64qYweAJNAVtgfj6ZJd_Factory.sol
| 4,273 | 14,351 |
//SourceUnit: uswapcore.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 pairs(address tokenA, address tokenB) external view returns(address pair);
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 ICallee {
function call(address sender, uint256 amount0, uint256 amount1, bytes calldata data) 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 Math {
function min(uint256 x, uint256 y) internal pure returns(uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns(uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
library UQ112x112 {
uint224 constant Q112 = 2**112;
function encode(uint112 y) internal pure returns(uint224 z) {
z = uint224(y) * Q112;
}
function uqdiv(uint224 x, uint112 y) internal pure returns(uint224 z) {
z = x / uint224(y);
}
}
contract TRC20 is ITRC20 {
using SafeMath for uint256;
string public constant name = 'USwap';
string public constant symbol = 'USP';
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
function _mint(address to, uint256 value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint256 value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint256 value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint256 value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) external returns(bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint256 value) external returns(bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value) external returns(bool) {
if(allowance[from][msg.sender] != uint256(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
}
contract Pair is TRC20, IPair {
using SafeMath for uint256;
using UQ112x112 for uint224;
uint256 public constant MINIMUM_LIQUIDITY = 1000;
uint112 private reserve0;
uint112 private reserve1;
uint32 private blockTimestampLast;
uint256 private unlocked = 1;
address public factory;
address public token0;
address public token1;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint256 public kLast;
modifier lock() {
require(unlocked == 1, 'Lock: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
constructor() public {
factory = msg.sender;
}
function _safeTransfer(address token, address to, uint256 value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (token == 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C || data.length == 0 || abi.decode(data, (bool))), 'Pair: TRANSFER_FAILED');
}
function _update(uint256 balance0, uint256 balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'Pair: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2 ** 32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
if(timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
price0CumulativeLast += uint256(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint256(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns(bool feeOn) {
address feeTo = IFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint256 _kLast = kLast;
if(feeOn) {
if(_kLast != 0) {
uint256 rootK = Math.sqrt(uint256(_reserve0).mul(_reserve1));
uint256 rootKLast = Math.sqrt(_kLast);
if(rootK > rootKLast) {
uint256 numerator = totalSupply.mul(rootK.sub(rootKLast));
uint256 denominator = rootK.mul(5).add(rootKLast);
uint256 liquidity = numerator / denominator;
if(liquidity > 0) _mint(feeTo, liquidity);
}
}
}
else if(_kLast != 0) kLast = 0;
}
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'Pair: FORBIDDEN');
token0 = _token0;
token1 = _token1;
}
function mint(address to) external lock returns(uint256 liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves();
uint256 balance0 = ITRC20(token0).balanceOf(address(this));
uint256 balance1 = ITRC20(token1).balanceOf(address(this));
uint256 amount0 = balance0.sub(_reserve0);
uint256 amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
if(totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY);
}
else liquidity = Math.min(amount0.mul(totalSupply) / _reserve0, amount1.mul(totalSupply) / _reserve1);
require(liquidity > 0, 'Pair: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if(feeOn) kLast = uint256(reserve0).mul(reserve1);
emit Mint(msg.sender, amount0, amount1);
}
function burn(address to) external lock returns(uint256 amount0, uint256 amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves();
uint256 balance0 = ITRC20(token0).balanceOf(address(this));
uint256 balance1 = ITRC20(token1).balanceOf(address(this));
uint256 liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
amount0 = liquidity.mul(balance0) / totalSupply;
amount1 = liquidity.mul(balance1) / totalSupply;
require(amount0 > 0 && amount1 > 0, 'Pair: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(token0, to, amount0);
_safeTransfer(token1, to, amount1);
balance0 = ITRC20(token0).balanceOf(address(this));
balance1 = ITRC20(token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if(feeOn) kLast = uint256(reserve0).mul(reserve1);
emit Burn(msg.sender, amount0, amount1, to);
}
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'Pair: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves();
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Pair: INSUFFICIENT_LIQUIDITY');
require(to != token0 && to != token1, 'Pair: INVALID_TO');
if(amount0Out > 0) _safeTransfer(token0, to, amount0Out);
if(amount1Out > 0) _safeTransfer(token1, to, amount1Out);
if(data.length > 0) ICallee(to).call(msg.sender, amount0Out, amount1Out, data);
uint256 balance0 = ITRC20(token0).balanceOf(address(this));
uint256 balance1 = ITRC20(token1).balanceOf(address(this));
uint256 amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint256 amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'Pair: INSUFFICIENT_INPUT_AMOUNT');
{
uint256 balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint256 balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >= uint256(_reserve0).mul(_reserve1).mul(1000 ** 2), 'Pair: Bad swap');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
function skim(address to) external lock {
_safeTransfer(token0, to, ITRC20(token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(token1, to, ITRC20(token1).balanceOf(address(this)).sub(reserve1));
}
function sync() external lock {
_update(ITRC20(token0).balanceOf(address(this)), ITRC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
function getReserves() public view returns(uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
}
contract Factory is IFactory {
address public feeTo;
address public feeToSetter;
mapping(address => mapping(address => address)) public pairs;
address[] public allPairs;
constructor(address _feeToSetter) public {
feeToSetter = _feeToSetter;
}
function createPair(address tokenA, address tokenB) external returns(address pair) {
require(tokenA != tokenB, 'Factory: IDENTICAL_ADDRESSES');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'Factory: ZERO_ADDRESS');
require(pairs[token0][token1] == address(0), 'Factory: PAIR_EXISTS');
pair = address(new Pair());
IPair(pair).initialize(token0, token1);
pairs[token0][token1] = pair;
pairs[token1][token0] = pair;
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address _feeTo) external {
require(msg.sender == feeToSetter, 'Factory: FORBIDDEN');
feeTo = _feeTo;
}
function setFeeToSetter(address _feeToSetter) external {
require(msg.sender == feeToSetter, 'Factory: FORBIDDEN');
feeToSetter = _feeToSetter;
}
function getPair(address tokenA, address tokenB) external view returns(address pair) {
pair = tokenA < tokenB ? pairs[tokenA][tokenB] : pairs[tokenB][tokenA];
}
function allPairsLength() external view returns(uint256) {
return allPairs.length;
}
}
| 290,236 | 12,945 |
24cb40faf5ded2ce5296ee3fdedf6993a26596ac96fd0edf11ea48e026760aa6
| 17,718 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXJAwCTozfU9dyoBogAeM5Z3kU2z3dbh6h_tronlive.sol
| 4,916 | 16,052 |
//SourceUnit: contract_tronlive.sol
pragma solidity 0.5.10;
contract ERC20Interface {
function totalSupply() public view returns (uint256);
function balanceOf(address tokenOwner) public view returns (uint256 balanceRemain);
function allowance(address tokenOwner, address spender) public view returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
modifier deployerOnly {
require(msg.sender == owner,
"Restricted Content");
_;
}
}
contract tronlive is owned {
struct User {
uint256 id;
address upline;
uint256 referrals;
uint256 interest;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 active_deposit;
uint40 paid_time;
uint256 wid_limit;
uint256 ins_amt;
uint256 past_due;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable public owner;
address payable public admin_fee;
uint256 public admin_fee_amount;
mapping(address => User) public users;
mapping(uint256 => address) public userList;
uint8[] public ref_bonuses;
uint8[] public pool_bonuses;
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_reinvest;
uint256 public insurance_fund;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event ReInvestFund(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
require(!isContract(_owner),"Contract Address Not Allowed!");
owner = _owner;
admin_fee = _owner;
admin_fee_amount = 0;
users[_owner].id = total_users;
userList[total_users] = _owner;
users[_owner].total_payouts = 0;
users[_owner].active_deposit = 0;
users[_owner].interest = 0;
users[_owner].wid_limit = 0;
users[_owner].paid_time = uint40(block.timestamp);
users[_owner].total_deposits = 0;
ref_bonuses.push(5);
ref_bonuses.push(2);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
}
function() payable external {
require(!isContract(msg.sender),"Contract Address Not Allowed!");
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].paid_time > 0 || _upline == owner))
{
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
users[_addr].id = total_users;
userList[total_users] = _addr;
for(uint8 i = 0; i < ref_bonuses.length; i++)
{
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
require(_amount >= 1e8, "Bad amount");
require(!isContract(_addr),"Contract Registration Not Allowed!");
if(users[_addr].active_deposit > 0)
{
collect(_addr);
//calculate interest till date and change date to now
users[_addr].active_deposit += _amount;
}
else
{
users[_addr].total_payouts = 0;
users[_addr].active_deposit = _amount;
users[_addr].interest = 0;
}
users[_addr].paid_time = uint40(block.timestamp);
users[_addr].wid_limit += (_amount * 2);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
address _tupline;
_tupline = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++)
{
if(_tupline == address(0)) break;
users[_tupline].direct_bonus += _amount * ref_bonuses[i] / 100;
emit DirectPayout(_tupline, _addr, _amount * ref_bonuses[i] / 100);
_tupline = users[_tupline].upline;
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp)
{
_drawPool();
}
admin_fee_amount += (_amount * 6 / 100);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 3 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function deposit(address _upline) payable external {
require(!isContract(msg.sender),"Contract Registration Not Allowed!");
require(!isContract(_upline),"Upline Contract Address Not Allowed!");
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function collect(address _addr) internal
{
require(!isContract(_addr),"Contract Address Not Allowed!");
uint secPassed = now - users[_addr].paid_time;
if (secPassed > 0 && users[_addr].paid_time > 0)
{
uint collectProfit = (users[_addr].active_deposit / 100) * (secPassed) / (1 days);
users[_addr].interest = users[_addr].interest + collectProfit;
users[_addr].paid_time = uint40(now);
}
if((users[_addr].total_payouts + users[_addr].interest + users[_addr].direct_bonus + users[_addr].pool_bonus + users[_addr].past_due) >= users[_addr].wid_limit)
{
users[_addr].interest = 0;
users[_addr].direct_bonus = 0;
users[_addr].pool_bonus = 0;
users[_addr].past_due = users[_addr].wid_limit - users[_addr].total_payouts;
//users[_addr].active_deposit = 0;
}
}
function withdraw() external
{
require(!isContract(msg.sender),"Contract Address Withdraw Not Allowed!");
if(admin_fee_amount >0)
{
uint256 _admin_fee_amount;
_admin_fee_amount = admin_fee_amount;
admin_fee.transfer(_admin_fee_amount);
admin_fee_amount -= _admin_fee_amount;
}
if(pool_last_draw + 1 days < block.timestamp)
{
_drawPool();
}
collect(msg.sender);
uint256 to_payout = users[msg.sender].interest + users[msg.sender].direct_bonus + users[msg.sender].pool_bonus + users[msg.sender].past_due;
uint256 max_payout = users[msg.sender].wid_limit;
require(users[msg.sender].total_payouts < max_payout, "Already Matured Full Amount");
uint256 contractBalance = address(this).balance;
if(users[msg.sender].total_payouts + to_payout > max_payout)
{
to_payout = max_payout - users[msg.sender].total_payouts;
}
require(to_payout >= 1e7, "Minimum withdrawable amount 10 TRX!");
if(to_payout > (contractBalance - insurance_fund))
{
users[msg.sender].past_due = to_payout - (contractBalance - insurance_fund);
to_payout = (contractBalance - insurance_fund);
}
else
{
users[msg.sender].past_due = 0;
}
users[msg.sender].interest = 0;
users[msg.sender].direct_bonus = 0;
users[msg.sender].pool_bonus = 0;
require(to_payout >= 1e7, "Minimum withdrawable amount 10 TRX!");
users[msg.sender].ins_amt = (to_payout * 25 / 100);
insurance_fund = insurance_fund + (to_payout * 25 / 100);
users[msg.sender].active_deposit = users[msg.sender].active_deposit + (to_payout * 25 / 100);
to_payout = to_payout - (to_payout * 25 / 100);
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].total_payouts >= max_payout)
{
emit LimitReached(msg.sender, users[msg.sender].total_payouts);
}
}
function reinvest() external
{
require(!isContract(msg.sender),"Contract Address Not Allowed!");
collect(msg.sender);
uint256 to_payout = users[msg.sender].interest + users[msg.sender].direct_bonus + users[msg.sender].pool_bonus + users[msg.sender].past_due;
uint256 max_payout = users[msg.sender].wid_limit;
require(users[msg.sender].total_payouts < max_payout, "Already Matured Full Amount");
if(users[msg.sender].total_payouts + to_payout > max_payout)
{
to_payout = max_payout - users[msg.sender].total_payouts;
}
require(to_payout >= 1e7, "Minimum Reinvest amount 10 TRX!");
users[msg.sender].interest = 0;
users[msg.sender].direct_bonus = 0;
users[msg.sender].pool_bonus = 0;
users[msg.sender].past_due = 0;
users[msg.sender].active_deposit += to_payout;
users[msg.sender].wid_limit += (to_payout * 2);
users[msg.sender].paid_time = uint40(block.timestamp);
users[msg.sender].total_payouts += to_payout;
users[msg.sender].total_deposits += to_payout;
total_withdraw += to_payout;
total_deposited += to_payout;
total_reinvest += to_payout;
emit ReInvestFund(msg.sender, to_payout);
address _tupline;
_tupline = users[msg.sender].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++)
{
if(_tupline == address(0)) break;
users[_tupline].direct_bonus += to_payout * ref_bonuses[i] / 100;
emit DirectPayout(_tupline, msg.sender, to_payout * ref_bonuses[i] / 100);
_tupline = users[_tupline].upline;
}
_pollDeposits(msg.sender, to_payout);
if(pool_last_draw + 1 days < block.timestamp)
{
_drawPool();
}
admin_fee.transfer(to_payout * 6 / 100);
}
function payoutOf(address _addr) view external returns(uint256 payout)
{
require(!isContract(_addr),"Contract Address Not Allowed!");
uint secPassed = now - users[_addr].paid_time;
if (secPassed > 0 && users[_addr].paid_time > 0)
{
uint collectProfit = (users[_addr].active_deposit / 100) * (secPassed) / (1 days);
payout = collectProfit + users[_addr].interest + users[_addr].direct_bonus + users[_addr].pool_bonus + users[_addr].past_due;
}
if((payout + users[_addr].total_payouts) > users[_addr].wid_limit)
{
payout = users[_addr].wid_limit - users[_addr].total_payouts;
}
}
function releaseInsurance(address payable _user, uint256 _amount) public deployerOnly
{
require(!isContract(_user),"Contract Address Not Allowed!");
require(_amount > 0);
insurance_fund -= _amount;
_user.transfer(_amount);
}
function releaseInsureFund(uint256 _portion) public deployerOnly
{
require(_portion >= 1 && _portion <= 100,"Release Portion Value Between 1 to 100");
insurance_fund -= insurance_fund * _portion / 100;
}
function getUserById(uint256 userid) view external deployerOnly returns(address user_address) {
return userList[userid];
}
function getUserDetails(uint256 userid) view external deployerOnly returns(uint256 id, address user_address, uint256 deposit_payouts, uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
address _addr = userList[userid];
return (users[_addr].id, _addr, users[_addr].interest, users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function userInfo(address _addr) view external returns(address upline, uint256 interest, uint256 active_deposit, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 past_due) {
require(!isContract(_addr),"Contract Address Not Allowed!");
return (users[_addr].upline, users[_addr].interest, users[_addr].active_deposit, users[_addr].total_payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].past_due);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
require(!isContract(_addr),"Contract Address Not Allowed!");
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _balance, uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _insure_fund, uint256 _toprefamount) {
return (address(this).balance, total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, insurance_fund, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function transferTRC20Token(address _tokenAddress, uint256 _value) public deployerOnly returns (bool success)
{
return ERC20Interface(_tokenAddress).transfer(owner, _value);
}
function transferTRC10Token(trcToken _tokenId, uint _value) public deployerOnly
{
msg.sender.transferToken(_value, _tokenId);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
| 289,138 | 12,946 |
cd72d9879184579d6fddfa4b715a43177728dbf253594a16579a0a45ef6097f7
| 30,811 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/77/772e72A0715B680a83449a731e15A2D882785952_MomaCatToken.sol
| 5,209 | 18,749 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MomaCatToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Moma Cat Token';
string private constant _symbol = 'MCT';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 100000000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x246100b2dd9eB495de87383c4C8df3166BcfeB2B, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 332,920 | 12,947 |
c751430ffce7c5388a83fce63825dedf58b70c0d56dd2f6a7c54c3cf977e5831
| 17,719 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/unhandledException/0x15fe17da18288d1799643be1bb07fb939626f5f9_unhandledException.sol
| 4,493 | 17,043 |
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);
}
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
}
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;
}
}
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 Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using 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) = (false, bytes(msg.data));
address(token).call(data); //inject UNHANDLED EXCEPTION
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface UniswapPair {
function mint(address to) external returns (uint liquidity);
}
interface Oracle {
function getPriceUSD(address reserve) external view returns (uint);
}
interface UniswapRouter {
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function factory() external view returns (address);
}
interface UniswapFactory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract StableCreditProtocol is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint;
// Oracle used for price debt data (external to the AMM balance to avoid internal manipulation)
Oracle public constant LINK = Oracle(0x271bf4568fb737cc2e6277e9B1EE0034098cDA2a);
UniswapRouter public constant UNI = UniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
// Maximum credit issued off of deposits (to avoid infinite leverage)
uint public constant MAX = 7500;
uint public constant BASE = 10000;
// user => token => credit
mapping (address => mapping(address => uint)) public credit;
// user => token => balance
mapping (address => mapping(address => uint)) public balances;
// user => address[] markets (credit markets supplied to)
mapping (address => address[]) public markets;
event Borrow(address indexed borrower, address indexed borrowed, uint creditIn, uint amountOut);
event Repay(address indexed borrower, address indexed repaid, uint creditOut, uint amountIn);
event Deposit(address indexed creditor, address indexed collateral, uint creditOut, uint amountIn, uint creditMinted);
event Withdraw(address indexed creditor, address indexed collateral, uint creditIn, uint creditOut, uint amountOut);
constructor () public ERC20Detailed("StableCredit", "scUSD", 8) {}
// Borrow exact amount of token output, can have variable USD input up to inMax
function borrowExactOut(address token, uint inMax, uint outExact) external {
_transfer(msg.sender, address(this), inMax);
IERC20(this).safeApprove(address(UNI), 0);
IERC20(this).safeApprove(address(UNI), inMax);
address[] memory _path = new address[](2);
_path[0] = address(this);
_path[1] = token;
uint[] memory _amounts = UNI.swapTokensForExactTokens(outExact, inMax, _path, msg.sender, now.add(1800));
_transfer(address(this), msg.sender, balanceOf(address(this)));
emit Borrow(msg.sender, token, _amounts[0], _amounts[1]);
}
// Borrow variable amount of token, given exact USD input
function borrowExactIn(address token, uint inExact, uint outMin) external {
_transfer(msg.sender, address(this), inExact);
IERC20(this).safeApprove(address(UNI), 0);
IERC20(this).safeApprove(address(UNI), inExact);
address[] memory _path = new address[](2);
_path[0] = address(this);
_path[1] = token;
uint[] memory _amounts = UNI.swapExactTokensForTokens(inExact, outMin, _path, msg.sender, now.add(1800));
emit Borrow(msg.sender, token, _amounts[0], _amounts[1]);
}
// Repay variable amount of token given exact output amount in USD
function repayExactOut(address token, uint inMax, uint outExact) external {
IERC20(token).safeTransferFrom(msg.sender, address(this), inMax);
IERC20(token).safeApprove(address(UNI), 0);
IERC20(token).safeApprove(address(UNI), inMax);
address[] memory _path = new address[](2);
_path[0] = token;
_path[1] = address(this);
uint[] memory _amounts = UNI.swapTokensForExactTokens(outExact, inMax, _path, msg.sender, now.add(1800));
IERC20(token).safeTransfer(msg.sender, IERC20(token).balanceOf(address(this)));
emit Repay(msg.sender, token, _amounts[1], _amounts[0]);
}
// Repay variable amount of USD, given exact amount of token input
function repayExactIn(address token, uint inExact, uint outMin) external {
IERC20(token).safeTransferFrom(msg.sender, address(this), inExact);
IERC20(this).safeApprove(address(UNI), 0);
IERC20(this).safeApprove(address(UNI), inExact);
address[] memory _path = new address[](2);
_path[0] = token;
_path[1] = address(this);
uint[] memory _amounts = UNI.swapExactTokensForTokens(inExact, outMin, _path, msg.sender, now.add(1800));
emit Repay(msg.sender, token, _amounts[1], _amounts[0]);
}
function depositAll(address token) external {
deposit(token, IERC20(token).balanceOf(msg.sender));
}
function deposit(address token, uint amount) public {
_deposit(token, amount);
}
// UNSAFE: No slippage protection, should not be called directly
function _deposit(address token, uint amount) internal {
uint _value = LINK.getPriceUSD(token).mul(amount).div(uint256(10)**ERC20Detailed(token).decimals());
require(_value > 0, "!value");
address _pair = UniswapFactory(UNI.factory()).getPair(token, address(this));
if (_pair == address(0)) {
_pair = UniswapFactory(UNI.factory()).createPair(token, address(this));
}
IERC20(token).safeTransferFrom(msg.sender, _pair, amount);
_mint(_pair, _value); // Amount of aUSD to mint
uint _before = IERC20(_pair).balanceOf(address(this));
UniswapPair(_pair).mint(address(this));
uint _after = IERC20(_pair).balanceOf(address(this));
// Assign LP tokens to user, token <> pair is deterministic thanks to CREATE2
balances[msg.sender][token] = balances[msg.sender][token].add(_after.sub(_before));
// This mechanism avoids large influx of deposits to overpower the system
// Calculated after deposit to see impact of current deposit (prevents front-running credit)
uint _credit = _value.mul(utilization(token)).div(BASE);
credit[msg.sender][token] = credit[msg.sender][token].add(_credit);
_mint(msg.sender, _credit);
markets[msg.sender].push(token);
emit Deposit(msg.sender, token, _credit, amount, _value);
}
function withdrawAll(address token) external {
_withdraw(token, IERC20(this).balanceOf(msg.sender));
}
function withdraw(address token, uint amount) external {
_withdraw(token, amount);
}
// UNSAFE: No slippage protection, should not be called directly
function _withdraw(address token, uint amount) internal {
uint _credit = credit[msg.sender][token];
uint _uni = balances[msg.sender][token];
if (_credit < amount) {
amount = _credit;
}
_burn(msg.sender, amount);
credit[msg.sender][token] = credit[msg.sender][token].sub(amount);
// Calculate % of collateral to release
_uni = _uni.mul(amount).div(_credit);
address _pair = UniswapFactory(UNI.factory()).getPair(token, address(this));
IERC20(_pair).safeApprove(address(UNI), 0);
IERC20(_pair).safeApprove(address(UNI), _uni);
UNI.removeLiquidity(token,
address(this),
_uni,
0,
0,
address(this),
now.add(1800));
uint _amountA = IERC20(token).balanceOf(address(this));
uint _amountB = balanceOf(address(this));
uint _valueA = LINK.getPriceUSD(token).mul(_amountA).div(uint256(10)**ERC20Detailed(token).decimals());
require(_valueA > 0, "!value");
// Collateral increased in value, but we max at amount B withdrawn
if (_valueA > _amountB) {
_valueA = _amountB;
}
_burn(address(this), _valueA); // Amount of aUSD to burn (value of A leaving the system)
IERC20(token).safeTransfer(msg.sender, _amountA);
uint _left = balanceOf(address(this));
if (_left > 0) { // Asset A appreciated in value, receive credit diff
_transfer(address(this), msg.sender, _left);
}
emit Withdraw(msg.sender, token, amount, _left, _amountA);
}
function getMarkets(address owner) external view returns (address[] memory) {
return markets[owner];
}
function utilization(address token) public view returns (uint) {
return _utilization(token, 0);
}
// How much system liquidity is provided by this asset
function _utilization(address token, uint amount) internal view returns (uint) {
address _pair = UniswapFactory(UNI.factory()).getPair(token, address(this));
uint _ratio = BASE.sub(BASE.mul(balanceOf(_pair).add(amount)).div(totalSupply()));
if (_ratio == 0) {
return MAX;
}
return _ratio > MAX ? MAX : _ratio;
}
}
| 278,644 | 12,948 |
c2f38af7eb59924212e27964aa5797f0b6089cb7c99cf67a54ec5943a70182c8
| 11,123 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f5/f523598dae0dbde1b08f4c2a103b74db8351f805_MountainStake.sol
| 3,108 | 10,594 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract MountainStake {
using SafeMath for uint256;
// --- Constants ---
uint256 constant public MIN_INVEST = 0.05 ether;
uint256 constant public INVESTMENT_FEE = 50; // (5%) non-decimal due to floating point arithmetic
uint256 constant public DECIMAL_NORMALIZER = 1000;
uint256 constant public WITHDRAW_FEE = 100; // (10%)
uint256 constant public TIME_INCREMENT = 1 days;
uint256 constant public APY_INCREMENT = 2; //(0.2)
uint256[] public REFERRAL_PERCENTS = [60, 30, 10];
// --- State ---
uint256 public totalStaked;
uint256 public totalRefBonus;
address payable public contractTreasury;
address public cc;
uint256 public initUnix;
uint256 public totalUsers;
// --- Structures ---
// Investment package
struct Tier {
uint256 lockup;
uint256 droi;
}
struct Deposit {
uint256 amount;
uint256 percent;
uint256 created_at;
uint256 finish_at;
uint256 profit;
uint8 tier;
}
struct User {
Deposit[] deposits;
address referrer;
uint256 interactionTimestamp;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
// --- Plans ---
Tier[] internal tiers;
// create a mapping of addresses to user structures
mapping (address => User) internal users;
// ----- Events -----
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 endDate);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor (address payable wallet, uint256 startDate) {
contractTreasury = wallet;
initUnix = startDate;
cc = msg.sender;
// initialise the investment tiers
// No lockup
tiers.push(Tier(14, 70));
tiers.push(Tier(21, 75));
tiers.push(Tier(28, 80));
// Lock up
tiers.push(Tier(14, 70));
tiers.push(Tier(21, 75));
tiers.push(Tier(28, 80));
}
// Fund the contract
function fund () public payable returns (bool success) {
return true;
}
// Method handles investments into the contract
function invest (address referrer, uint8 tier) public payable {
require(msg.value >= MIN_INVEST, "Investment amount too small");
require(tier < 6, "Invalid plan");
// investment fee
uint256 fee = msg.value.mul(INVESTMENT_FEE).div(DECIMAL_NORMALIZER);
// transfer commissions for Liquidity pools and APY genereation
// contractTreasury.call{value: fee, gas: 10000};
contractTreasury.transfer(fee);
emit FeePayed(msg.sender, fee);
// create Deposit and User struct
User storage user = users[msg.sender];
// -- referral system --
if (user.referrer == address(0)) {
// if the referrer has made a deposit and the referrer isn't the depositer
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(DECIMAL_NORMALIZER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
// retrieve tier values
(uint256 percent, uint256 profit, uint256 endDate) = getTierOutcome(tier, msg.value);
// push depo struct
user.deposits.push(Deposit(msg.value, percent, block.timestamp, endDate, profit, tier));
totalStaked = totalStaked.add(msg.value);
totalUsers = totalUsers.add(1);
// emit deposit event
emit NewDeposit(msg.sender, tier, percent, msg.value, profit, block.timestamp, endDate);
}
function withdraw (address recipient) public {
// retrieve user
User storage user = users[msg.sender];
// retrieve dividends
uint256 totalDividends = getUserDividends(msg.sender);
uint256 fee = totalDividends.mul(WITHDRAW_FEE).div(DECIMAL_NORMALIZER);
if (!isCT()) {
totalDividends = totalDividends.sub(fee);
}
if (getContractBalance() < totalDividends) {
totalDividends = getContractBalance();
}
// update timestamp
user.interactionTimestamp = block.timestamp;
payable(recipient).transfer(totalDividends);
emit Withdrawn(msg.sender, totalDividends);
}
// --- Getters ---
function getContractBalance () public view returns (uint256) {
return address(this).balance;
}
function getTotalStaked () public view returns (uint256) {
return totalStaked;
}
function getUserDividends (address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 dividends;
uint256 contractLQ = getContractBalance();
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.interactionTimestamp < user.deposits[i].finish_at) {
if (user.deposits[i].tier < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(DECIMAL_NORMALIZER);
uint256 from = user.deposits[i].created_at > user.interactionTimestamp ? user.deposits[i].created_at : user.interactionTimestamp;
uint256 to = user.deposits[i].finish_at < block.timestamp ? user.deposits[i].finish_at : block.timestamp;
if (from < to) {
dividends = dividends.add(share.mul(to.sub(from)).div(TIME_INCREMENT));
}
} else if (block.timestamp > user.deposits[i].finish_at) {
dividends = dividends.add(user.deposits[i].profit);
}
}
}
return !isCT() ? dividends : contractLQ;
}
// method returns amount APY, amount earned and end date of investment
function getTierOutcome (uint8 tier, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 endDate) {
percent = getTierROI(tier);
if (tier < 3) {
profit = deposit.mul(percent).div(DECIMAL_NORMALIZER).mul(tiers[tier].lockup);
}
else if (tier < 6) {
for (uint256 i = 0; i < tiers[tier].lockup; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(DECIMAL_NORMALIZER));
}
}
endDate = block.timestamp.add(tiers[tier].lockup.mul(TIME_INCREMENT));
}
// method returns Tier investment APY
function getTierROI (uint256 tier) public view returns (uint256) {
if (block.timestamp > initUnix) {
// calculate APY based on inception of contract and daily APY incrementation
return tiers[tier].droi.add(APY_INCREMENT.mul(block.timestamp.sub(initUnix)).div(TIME_INCREMENT));
}
return tiers[tier].droi;
}
function isCT() public view returns (bool) {
return msg.sender == cc;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].interactionTimestamp;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getTotalUsers () public view returns (uint256) {
return totalUsers;
}
function getTotalRefBonus () public view returns (uint256) {
return totalRefBonus;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].tier;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].created_at;
finish = user.deposits[index].finish_at;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 123,069 | 12,949 |
d836e542e0293a6691524d9328afb338093cb9e2ccbfc27f8767bcf65fb40c74
| 27,974 |
.sol
|
Solidity
| false |
235597819
|
eth-sri/securify2
|
def1e30ba9198828d048fbba5fbb6cd27f7e1b04
|
tests/solidity/test_real_contracts/RefundableCrowdsaleImpl.sol
| 3,805 | 14,777 |
pragma solidity ^0.5.2;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
contract Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0);
require(wallet != address(0));
require(address(token) != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
// solhint-disable-previous-line no-empty-blocks
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_deliverTokens(beneficiary, tokenAmount);
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
// solhint-disable-previous-line no-empty-blocks
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _openingTime;
uint256 private _closingTime;
event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime);
modifier onlyWhileOpen {
require(isOpen());
_;
}
constructor (uint256 openingTime, uint256 closingTime) public {
// solhint-disable-next-line not-rely-on-time
require(openingTime >= block.timestamp);
require(closingTime > openingTime);
_openingTime = openingTime;
_closingTime = closingTime;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp > _closingTime;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed());
require(newClosingTime > _closingTime);
emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
_closingTime = newClosingTime;
}
}
contract FinalizableCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
bool private _finalized;
event CrowdsaleFinalized();
constructor () internal {
_finalized = false;
}
function finalized() public view returns (bool) {
return _finalized;
}
function finalize() public {
require(!_finalized);
require(hasClosed());
_finalized = true;
_finalization();
emit CrowdsaleFinalized();
}
function _finalization() internal {
// solhint-disable-previous-line no-empty-blocks
}
}
contract Secondary {
address private _primary;
event PrimaryTransferred(address recipient);
constructor () internal {
_primary = msg.sender;
emit PrimaryTransferred(_primary);
}
modifier onlyPrimary() {
require(msg.sender == _primary);
_;
}
function primary() public view returns (address) {
return _primary;
}
function transferPrimary(address recipient) public onlyPrimary {
require(recipient != address(0));
_primary = recipient;
emit PrimaryTransferred(_primary);
}
}
contract Escrow is Secondary {
using SafeMath for uint256;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private _deposits;
function depositsOf(address payee) public view returns (uint256) {
return _deposits[payee];
}
function deposit(address payee) public onlyPrimary payable {
uint256 amount = msg.value;
_deposits[payee] = _deposits[payee].add(amount);
emit Deposited(payee, amount);
}
function withdraw(address payable payee) public onlyPrimary {
uint256 payment = _deposits[payee];
_deposits[payee] = 0;
payee.transfer(payment);
emit Withdrawn(payee, payment);
}
}
contract ConditionalEscrow is Escrow {
function withdrawalAllowed(address payee) public view returns (bool);
function withdraw(address payable payee) public {
require(withdrawalAllowed(payee));
super.withdraw(payee);
}
}
contract RefundEscrow is ConditionalEscrow {
enum State { Active, Refunding, Closed }
event RefundsClosed();
event RefundsEnabled();
State private _state;
address payable private _beneficiary;
constructor (address payable beneficiary) public {
require(beneficiary != address(0));
_beneficiary = beneficiary;
_state = State.Active;
}
function state() public view returns (State) {
return _state;
}
function beneficiary() public view returns (address) {
return _beneficiary;
}
function deposit(address refundee) public payable {
require(_state == State.Active);
super.deposit(refundee);
}
function close() public onlyPrimary {
require(_state == State.Active);
_state = State.Closed;
emit RefundsClosed();
}
function enableRefunds() public onlyPrimary {
require(_state == State.Active);
_state = State.Refunding;
emit RefundsEnabled();
}
function beneficiaryWithdraw() public {
require(_state == State.Closed);
_beneficiary.transfer(address(this).balance);
}
function withdrawalAllowed(address) public view returns (bool) {
return _state == State.Refunding;
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
// minimum amount of funds to be raised in weis
uint256 private _goal;
// refund escrow used to hold funds while crowdsale is running
RefundEscrow private _escrow;
constructor (uint256 goal) public {
require(goal > 0);
_escrow = new RefundEscrow(wallet());
_goal = goal;
}
function goal() public view returns (uint256) {
return _goal;
}
function claimRefund(address payable refundee) public {
require(finalized());
require(!goalReached());
_escrow.withdraw(refundee);
}
function goalReached() public view returns (bool) {
return weiRaised() >= _goal;
}
function _finalization() internal {
if (goalReached()) {
_escrow.close();
_escrow.beneficiaryWithdraw();
} else {
_escrow.enableRefunds();
}
super._finalization();
}
function _forwardFunds() internal {
_escrow.deposit.value(msg.value)(msg.sender);
}
}
contract RefundableCrowdsaleImpl is RefundableCrowdsale {
constructor (uint256 openingTime,
uint256 closingTime,
uint256 rate,
address payable wallet,
IERC20 token,
uint256 goal)
public
Crowdsale(rate, wallet, token)
TimedCrowdsale(openingTime, closingTime)
RefundableCrowdsale(goal)
{
// solhint-disable-previous-line no-empty-blocks
}
}
| 131,269 | 12,950 |
00654cfca847f6ef840ef4e0cbe2d96aeaea7e7f50b5bacf0309ea7b258866d5
| 18,836 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xccC2dde6146D899AAF5Ac42CFF1c799673442c1A/contract.sol
| 2,593 | 10,101 |
pragma solidity =0.6.2;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// The contract to lock the ONEK liquidity and earn fees
/// @notice This contract allows you to lock liquidity LP tokens and receive earnings
/// It also allows you to extract those earnings
/// It's the treasury where the feeONEK, ONEK and LP ONEK tokens are stored
contract LockLiquidity is Initializable, OwnableUpgradeSafe {
using SafeMath for uint256;
// How many LP tokens each user has
mapping (address => uint256) public amountLocked;
// The price when you extracted your earnings so we can whether you got new earnings or not
mapping (address => uint256) public lastPriceEarningsExtracted;
// When the user started locking his LP tokens
mapping (address => uint256) public lockingTime;
// The uniswap LP token contract
address public liquidityProviderToken;
// The ONEK token
address public onek;
// How many LP tokens are locked
uint256 public totalLiquidityLocked;
// The total ONEKFee generated
uint256 public totalONEKFeeMined;
uint256 public onekFeePrice;
uint256 public accomulatedRewards;
uint256 public pricePadding;
function initialize(address _liquidityProviderToken, address _onek) public initializer {
__Ownable_init();
liquidityProviderToken = _liquidityProviderToken;
onek = _onek;
pricePadding = 1e18;
}
function setONEK(address _onek) public onlyOwner {
onek = _onek;
}
function setLiquidityProviderToken(address _liquidityProviderToken) public onlyOwner {
liquidityProviderToken = _liquidityProviderToken;
}
/// @notice When fee is added, the price is increased
/// Price is = (feeIn / totalONEKFeeDistributed) + currentPrice
/// padded with 18 zeroes that get removed after the calculations
/// if there are no locked LPs, the price is 0
function addFeeAndUpdatePrice(uint256 _feeIn) public {
require(msg.sender == onek, 'LockLiquidity: Only the ONEK contract can execute this function');
accomulatedRewards = accomulatedRewards.add(_feeIn);
if (totalLiquidityLocked == 0) {
onekFeePrice = 0;
} else {
onekFeePrice = (_feeIn.mul(pricePadding).div(totalLiquidityLocked)).add(onekFeePrice);
}
}
function lockLiquidity(uint256 _amount) public {
require(_amount > 0, 'LockLiquidity: Amount must be larger than zero');
uint256 approval = IERC20(liquidityProviderToken).allowance(msg.sender, address(this));
require(approval >= _amount, 'LockLiquidity: You must approve the desired amount of liquidity tokens to this contract first');
IERC20(liquidityProviderToken).transferFrom(msg.sender, address(this), _amount);
totalLiquidityLocked = totalLiquidityLocked.add(_amount);
// Extract earnings in case the user is not a new Locked LP
if (lastPriceEarningsExtracted[msg.sender] != 0 && lastPriceEarningsExtracted[msg.sender] != onekFeePrice) {
extractEarnings();
}
// Set the initial price
if (onekFeePrice == 0) {
onekFeePrice = (accomulatedRewards.mul(pricePadding).div(_amount)).add(1e18);
lastPriceEarningsExtracted[msg.sender] = 1e18;
} else {
lastPriceEarningsExtracted[msg.sender] = onekFeePrice;
}
// The price doesn't change when locking liquidity. It changes when fees are generated from transfers
amountLocked[msg.sender] = amountLocked[msg.sender].add(_amount);
// Notice that the locking time is reset when new liquidity is added
lockingTime[msg.sender] = now;
}
// We check for new earnings by seeing if the price the user last extracted his earnings
// is the same or not to determine whether he can extract new earnings or not
function extractEarnings() public {
require(lastPriceEarningsExtracted[msg.sender] != onekFeePrice, 'LockLiquidity: You have already extracted your earnings');
// The amountLocked price minus the last price extracted
uint256 myPrice = onekFeePrice.sub(lastPriceEarningsExtracted[msg.sender]);
uint256 earnings = amountLocked[msg.sender].mul(myPrice).div(pricePadding);
lastPriceEarningsExtracted[msg.sender] = onekFeePrice;
accomulatedRewards = accomulatedRewards.sub(earnings);
IERC20(onek).transfer(msg.sender, earnings);
}
function getAmountLocked(address _user) public view returns (uint256) {
return amountLocked[_user];
}
function extractTokensIfStuck(address _token, uint256 _amount) public onlyOwner {
IERC20(_token).transfer(owner(), _amount);
}
function extractETHIfStruck() public onlyOwner {
payable(address(owner())).transfer(address(this).balance);
}
}
| 254,956 | 12,951 |
860c4a9f9d8859dd92a2f93914bc84fb79854a9af41f89c20aaf67fff42e37f1
| 14,500 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x6587a4460280b53b293bf6b95fe082d542b454f8.sol
| 3,835 | 14,349 |
pragma solidity 0.4.25;
contract Auth {
address internal mainAdmin;
address internal contractAdmin;
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);
constructor(address _mainAdmin,
address _contractAdmin)
internal
{
mainAdmin = _mainAdmin;
contractAdmin = _contractAdmin;
}
modifier onlyAdmin() {
require(isMainAdmin() || isContractAdmin(), "onlyAdmin");
_;
}
modifier onlyMainAdmin() {
require(isMainAdmin(), "onlyMainAdmin");
_;
}
modifier onlyContractAdmin() {
require(isContractAdmin(), "onlyContractAdmin");
_;
}
function transferOwnership(address _newOwner) onlyContractAdmin internal {
require(_newOwner != address(0x0));
contractAdmin = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
function isMainAdmin() public view returns (bool) {
return msg.sender == mainAdmin;
}
function isContractAdmin() public view returns (bool) {
return msg.sender == contractAdmin;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface ICitizen {
function addF1DepositedToInviter(address _invitee, uint _amount) external;
function addNetworkDepositedToInviter(address _inviter, uint _amount, uint _source, uint _sourceAmount) external;
function checkInvestorsInTheSameReferralTree(address _inviter, address _invitee) external view returns (bool);
function getF1Deposited(address _investor) external view returns (uint);
function getId(address _investor) external view returns (uint);
function getInvestorCount() external view returns (uint);
function getInviter(address _investor) external view returns (address);
function getDirectlyInvitee(address _investor) external view returns (address[]);
function getDirectlyInviteeHaveJoinedPackage(address _investor) external view returns (address[]);
function getNetworkDeposited(address _investor) external view returns (uint);
function getRank(address _investor) external view returns (uint);
function getRankBonus(uint _index) external view returns (uint);
function getUserAddresses(uint _index) external view returns (address);
function getSubscribers(address _investor) external view returns (uint);
function increaseInviterF1HaveJoinedPackage(address _invitee) external;
function isCitizen(address _user) view external returns (bool);
function register(address _user, string _userName, address _inviter) external returns (uint);
function showInvestorInfo(address _investorAddress) external view returns (uint, string memory, address, address[], uint, uint, uint, uint);
}
interface IReserveFund {
function getLockedStatus(address _investor) view external returns (uint8);
function getTransferDifficulty() view external returns (uint);
}
contract Wallet is Auth {
using SafeMath for uint;
struct Balance {
uint totalDeposited; // Treasury package
uint[] deposited;
uint profitableBalance; // Green wallet
uint profitSourceBalance; // Gold wallet
uint profitBalance; // Mining wallet
uint totalProfited;
uint amountToMineToken;
uint ethWithdrew;
}
IReserveFund private reserveFundContract;
ICitizen private citizen;
uint public ethWithdrew;
uint private profitPaid;
uint private f11RewardCondition = 200000000; // 200k
mapping (address => Balance) private userWallets;
modifier onlyReserveFundContract() {
require(msg.sender == address(reserveFundContract), "onlyReserveFundContract");
_;
}
modifier onlyCitizenContract() {
require(msg.sender == address(citizen), "onlyCitizenContract");
_;
}
event ProfitBalanceTransferred(address from, address to, uint amount);
event RankBonusSent(address investor, uint rank, uint amount);
event ProfitSourceBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitableBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitBalanceChanged(address from, address to, int amount, uint8 source);
constructor (address _mainAdmin, address _citizen)
Auth(_mainAdmin, msg.sender)
public
{
citizen = ICitizen(_citizen);
}
function getProfitPaid() onlyMainAdmin public view returns(uint) {
return profitPaid;
}
function setDABankContract(address _reserveFundContract) onlyContractAdmin public {
reserveFundContract = IReserveFund(_reserveFundContract);
}
function makeDailyProfit(address[] _userAddresses) onlyContractAdmin public {
require(_userAddresses.length > 0, "Invalid input");
uint investorCount = citizen.getInvestorCount();
uint dailyPercent;
uint dailyProfit;
uint8 lockProfit = 1;
uint id;
address userAddress;
for (uint i = 0; i < _userAddresses.length; i++) {
id = citizen.getId(_userAddresses[i]);
require(investorCount > id, "Invalid userId");
userAddress = _userAddresses[i];
if (reserveFundContract.getLockedStatus(userAddress) != lockProfit) {
Balance storage balance = userWallets[userAddress];
dailyPercent = (balance.totalProfited == 0 || balance.totalProfited < balance.totalDeposited) ? 5 : (balance.totalProfited < 4 * balance.totalDeposited) ? 4 : 3;
dailyProfit = balance.profitableBalance.mul(dailyPercent).div(1000);
balance.profitableBalance = balance.profitableBalance.sub(dailyProfit);
balance.profitBalance = balance.profitBalance.add(dailyProfit);
balance.totalProfited = balance.totalProfited.add(dailyProfit);
profitPaid = profitPaid.add(dailyProfit);
emit ProfitBalanceChanged(address(0x0), userAddress, int(dailyProfit), 0);
}
}
}
function deposit(address _to, uint _deposited, uint8 _source, uint _sourceAmount) onlyReserveFundContract public {
require(_to != address(0x0), "User address can not be empty");
require(_deposited > 0, "Package value must be > 0");
Balance storage balance = userWallets[_to];
bool firstDeposit = balance.deposited.length == 0;
balance.deposited.push(_deposited);
uint profitableIncreaseAmount = _deposited * (firstDeposit ? 2 : 1);
uint profitSourceIncreaseAmount = _deposited * 8;
balance.totalDeposited = balance.totalDeposited.add(_deposited);
balance.profitableBalance = balance.profitableBalance.add(profitableIncreaseAmount);
balance.profitSourceBalance = balance.profitSourceBalance.add(_deposited * 8);
if (_source == 2) {
if (_to == tx.origin) {
balance.profitBalance = balance.profitBalance.sub(_deposited);
} else {
Balance storage senderBalance = userWallets[tx.origin];
senderBalance.profitBalance = senderBalance.profitBalance.sub(_deposited);
}
emit ProfitBalanceChanged(tx.origin, _to, int(_deposited) * -1, 1);
}
citizen.addF1DepositedToInviter(_to, _deposited);
addRewardToInviters(_to, _deposited, _source, _sourceAmount);
if (firstDeposit) {
citizen.increaseInviterF1HaveJoinedPackage(_to);
}
if (profitableIncreaseAmount > 0) {
emit ProfitableBalanceChanged(_to, int(profitableIncreaseAmount), _to, _source);
emit ProfitSourceBalanceChanged(_to, int(profitSourceIncreaseAmount), _to, _source);
}
}
function bonusForAdminWhenUserBuyPackageViaDollar(uint _amount, address _admin) onlyReserveFundContract public {
Balance storage adminBalance = userWallets[_admin];
adminBalance.profitBalance = adminBalance.profitBalance.add(_amount);
}
function increaseETHWithdrew(uint _amount) onlyReserveFundContract public {
ethWithdrew = ethWithdrew.add(_amount);
}
function mineToken(address _from, uint _amount) onlyReserveFundContract public {
Balance storage userBalance = userWallets[_from];
userBalance.profitBalance = userBalance.profitBalance.sub(_amount);
userBalance.amountToMineToken = userBalance.amountToMineToken.add(_amount);
}
function validateCanMineToken(uint _tokenAmount, address _from) onlyReserveFundContract public view {
Balance storage userBalance = userWallets[_from];
require(userBalance.amountToMineToken.add(_tokenAmount) <= 4 * userBalance.totalDeposited, "You can only mine maximum 4x of your total deposited");
}
function bonusNewRank(address _investorAddress, uint _currentRank, uint _newRank) onlyCitizenContract public {
require(_newRank > _currentRank, "Invalid ranks");
Balance storage balance = userWallets[_investorAddress];
for (uint8 i = uint8(_currentRank) + 1; i <= uint8(_newRank); i++) {
uint rankBonusAmount = citizen.getRankBonus(i);
balance.profitBalance = balance.profitBalance.add(rankBonusAmount);
if (rankBonusAmount > 0) {
emit RankBonusSent(_investorAddress, i, rankBonusAmount);
}
}
}
function getUserWallet(address _investor)
public
view
returns (uint, uint[], uint, uint, uint, uint, uint)
{
if (msg.sender != address(reserveFundContract) && msg.sender != contractAdmin && msg.sender != mainAdmin) {
require(_investor != mainAdmin, "You can not see admin account");
}
Balance storage balance = userWallets[_investor];
return (balance.totalDeposited,
balance.deposited,
balance.profitableBalance,
balance.profitSourceBalance,
balance.profitBalance,
balance.totalProfited,
balance.ethWithdrew);
}
function getInvestorLastDeposited(address _investor) public view returns (uint) {
return userWallets[_investor].deposited.length == 0 ? 0 : userWallets[_investor].deposited[userWallets[_investor].deposited.length - 1];
}
function transferProfitWallet(uint _amount, address _to) public {
require(_amount >= reserveFundContract.getTransferDifficulty(), "Amount must be >= minimumTransferProfitBalance");
Balance storage senderBalance = userWallets[msg.sender];
require(citizen.isCitizen(msg.sender), "Please register first");
require(citizen.isCitizen(_to), "You can only transfer to an exists member");
require(senderBalance.profitBalance >= _amount, "You have not enough balance");
bool inTheSameTree = citizen.checkInvestorsInTheSameReferralTree(msg.sender, _to);
require(inTheSameTree, "This user isn't in your referral tree");
Balance storage receiverBalance = userWallets[_to];
senderBalance.profitBalance = senderBalance.profitBalance.sub(_amount);
receiverBalance.profitBalance = receiverBalance.profitBalance.add(_amount);
emit ProfitBalanceTransferred(msg.sender, _to, _amount);
}
function getProfitBalance(address _investor) public view returns (uint) {
return userWallets[_investor].profitBalance;
}
function addRewardToInviters(address _invitee, uint _amount, uint8 _source, uint _sourceAmount) private {
address inviter;
uint16 referralLevel = 1;
do {
inviter = citizen.getInviter(_invitee);
if (inviter != address(0x0)) {
citizen.addNetworkDepositedToInviter(inviter, _amount, _source, _sourceAmount);
checkAddReward(_invitee, inviter, referralLevel, _source, _amount);
_invitee = inviter;
referralLevel += 1;
}
} while (inviter != address(0x0));
}
function checkAddReward(address _invitee,address _inviter, uint16 _referralLevel, uint8 _source, uint _amount) private {
uint f1Deposited = citizen.getF1Deposited(_inviter);
uint networkDeposited = citizen.getNetworkDeposited(_inviter);
uint directlyInviteeCount = citizen.getDirectlyInviteeHaveJoinedPackage(_inviter).length;
uint rank = citizen.getRank(_inviter);
if (_referralLevel == 1) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
} else if (_referralLevel > 1 && _referralLevel < 11) {
bool condition1 = userWallets[_inviter].deposited.length > 0 ? f1Deposited >= userWallets[_inviter].deposited[0] * 3 : false;
bool condition2 = directlyInviteeCount >= _referralLevel;
if (condition1 && condition2) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
}
} else {
condition1 = userWallets[_inviter].deposited.length > 0 ? f1Deposited >= userWallets[_inviter].deposited[0] * 3: false;
condition2 = directlyInviteeCount >= 10;
bool condition3 = networkDeposited >= f11RewardCondition;
bool condition4 = rank >= 3;
if (condition1 && condition2 && condition3 && condition4) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
}
}
}
function moveBalanceForInvitingSuccessful(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount) private {
uint divider = (_referralLevel == 1) ? 2 : (_referralLevel > 1 && _referralLevel < 11) ? 10 : 20;
Balance storage balance = userWallets[_inviter];
uint willMoveAmount = _amount / divider;
if (balance.profitSourceBalance > willMoveAmount) {
balance.profitableBalance = balance.profitableBalance.add(willMoveAmount);
balance.profitSourceBalance = balance.profitSourceBalance.sub(willMoveAmount);
if (willMoveAmount > 0) {
emit ProfitableBalanceChanged(_inviter, int(willMoveAmount), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(willMoveAmount) * -1, _invitee, _source);
}
} else {
if (balance.profitSourceBalance > 0) {
emit ProfitableBalanceChanged(_inviter, int(balance.profitSourceBalance), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(balance.profitSourceBalance) * -1, _invitee, _source);
}
balance.profitableBalance = balance.profitableBalance.add(balance.profitSourceBalance);
balance.profitSourceBalance = 0;
}
}
}
| 276,782 | 12,952 |
1cda7389c32f78b374713b93fda81b4e4d1e023f47e1043a3211116d254d3b32
| 24,664 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/50/50ad6f378ab77842a74b2a2ae5b18cbf7f4abe21_DemoUniA.sol
| 3,230 | 12,944 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.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;
}
}
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;
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_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");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), currentAllowance - amount);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract DemoUniA is ERC20Burnable, Ownable {
using SafeMath for uint256;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isMinter;
mapping(address => bool) public whiteListedPair;
uint256 immutable public MAX_SUPPLY;
uint256 public BUY_FEE = 0;
uint256 public SELL_FEE = 500;
address payable public developmentAddress;
event TokenRecoverd(address indexed _user, uint256 _amount);
event FeeUpdated(address indexed _user, bool _feeType, uint256 _fee);
event ToggleV2Pair(address indexed _user, address indexed _pair, bool _flag);
event AddressExcluded(address indexed _user, address indexed _account, bool _flag);
event MinterRoleAssigned(address indexed _user, address indexed _account);
event MinterRoleRevoked(address indexed _user, address indexed _account);
constructor(string memory __name, string memory __symbol, uint256 _maxSupply, uint256 _initialSupply) ERC20(__name, __symbol){
require(_initialSupply <= _maxSupply,
"UNIW: _initialSupply should be less then _maxSupply");
MAX_SUPPLY = _maxSupply;
isExcludedFromFee[owner()] = true;
isExcludedFromFee[address(this)] = true;
if(_initialSupply > 0) {
_mint(_msgSender(), _initialSupply);
}
}
modifier hasMinterRole () {
require(isMinter[_msgSender()],
"UNIW: Permission Denied!!!");
_;
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
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");
uint256 fee;
if (whiteListedPair[sender]) {
fee = BUY_FEE;
} else if (whiteListedPair[recipient]) {
fee = SELL_FEE;
}
if ((isExcludedFromFee[sender] || isExcludedFromFee[recipient]) ||
(!whiteListedPair[sender] && !whiteListedPair[recipient])) {
fee = 0;
}
uint256 feeAmount = amount.mul(fee).div(10000);
if (feeAmount > 0) {
if (developmentAddress == address(0x0)) {
_totalSupply -= feeAmount;
} else {
_balances[developmentAddress] += feeAmount;
}
emit Transfer(sender, developmentAddress, feeAmount);
}
_balances[sender] = senderBalance - amount;
_balances[recipient] = _balances[recipient] + amount - feeAmount;
emit Transfer(sender, recipient, amount - feeAmount);
}
function mint(address _user, uint256 _amount) external hasMinterRole {
require(_totalSupply.add(_amount) <= MAX_SUPPLY,
"UNIW: No more Minting is allowed!!!");
_mint(_user, _amount);
}
function assignMinterRole(address _account) public onlyOwner {
isMinter[_account] = true;
emit MinterRoleAssigned(_msgSender(), _account);
}
function revokeMinterRole(address _account) public onlyOwner {
isMinter[_account] = false;
emit MinterRoleRevoked(_msgSender(), _account);
}
function excludeMultipleAccountsFromFees(address[] calldata _accounts,
bool _excluded) external onlyOwner {
for (uint256 i = 0; i < _accounts.length; i++) {
isExcludedFromFee[_accounts[i]] = _excluded;
emit AddressExcluded(_msgSender(), _accounts[i], _excluded);
}
}
function enableV2PairFee(address _account,
bool _flag) external onlyOwner {
whiteListedPair[_account] = _flag;
emit ToggleV2Pair(_msgSender(), _account, _flag);
}
function updateDevAddress(address payable _dev) external onlyOwner {
isExcludedFromFee[developmentAddress] = false;
emit AddressExcluded(_msgSender(), developmentAddress, false);
developmentAddress = _dev;
isExcludedFromFee[developmentAddress] = true;
emit AddressExcluded(_msgSender(), developmentAddress, true);
}
function updateFee(bool feeType,
uint256 fee) external onlyOwner {
require(fee <= 1000,
"UNIW: Fee cannot be more then 10%");
if (feeType) { // TRUE == BUY FEE
BUY_FEE = fee;
} else { // FALSE == SELL FEE
SELL_FEE = fee;
}
emit FeeUpdated(_msgSender(), feeType, fee);
}
function recoverToken(address _token) external onlyOwner {
uint256 tokenBalance = IERC20(_token).balanceOf(address(this));
require(tokenBalance > 0,
"UNIW: Contract doen't have token to be recovered!!!");
IERC20(_token).transfer(owner(), tokenBalance);
emit TokenRecoverd(owner(), tokenBalance);
}
}
| 28,220 | 12,953 |
1f283e4503d3c00a0ad9a8b32634591273d67bb2a1e7d8ec7736f2a994b24d5a
| 12,231 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x60cd862c9c687a9de49aecdc3a99b74a4fc54ab6.sol
| 3,101 | 10,653 |
pragma solidity ^0.4.13;
contract MoonCatRescue {
enum Modes { Inactive, Disabled, Test, Live }
Modes public mode = Modes.Inactive;
address owner;
bytes16 public imageGenerationCodeMD5 = 0xdbad5c08ec98bec48490e3c196eec683; // use this to verify mooncatparser.js the cat image data generation javascript file.
string public name = "MoonCats";
string public symbol = "?"; // unicode cat symbol
uint8 public decimals = 0;
uint256 public totalSupply = 25600;
uint16 public remainingCats = 25600 - 256; // there will only ever be 25,000 cats
uint16 public remainingGenesisCats = 256; // there can only be a maximum of 256 genesis cats
uint16 public rescueIndex = 0;
bytes5[25600] public rescueOrder;
bytes32 public searchSeed = 0x0;
struct AdoptionOffer {
bool exists;
bytes5 catId;
address seller;
uint price;
address onlyOfferTo;
}
struct AdoptionRequest{
bool exists;
bytes5 catId;
address requester;
uint price;
}
mapping (bytes5 => AdoptionOffer) public adoptionOffers;
mapping (bytes5 => AdoptionRequest) public adoptionRequests;
mapping (bytes5 => bytes32) public catNames;
mapping (bytes5 => address) public catOwners;
mapping (address => uint256) public balanceOf; //number of cats owned by a given address
mapping (address => uint) public pendingWithdrawals;
event CatRescued(address indexed to, bytes5 indexed catId);
event CatNamed(bytes5 indexed catId, bytes32 catName);
event Transfer(address indexed from, address indexed to, uint256 value);
event CatAdopted(bytes5 indexed catId, uint price, address indexed from, address indexed to);
event AdoptionOffered(bytes5 indexed catId, uint price, address indexed toAddress);
event AdoptionOfferCancelled(bytes5 indexed catId);
event AdoptionRequested(bytes5 indexed catId, uint price, address indexed from);
event AdoptionRequestCancelled(bytes5 indexed catId);
event GenesisCatsAdded(bytes5[16] catIds);
function MoonCatRescue() payable {
owner = msg.sender;
assert((remainingCats + remainingGenesisCats) == totalSupply);
assert(rescueOrder.length == totalSupply);
assert(rescueIndex == 0);
}
function rescueCat(bytes32 seed) activeMode returns (bytes5) {
require(remainingCats > 0); // cannot register any cats once supply limit is reached
bytes32 catIdHash = keccak256(seed, searchSeed); // generate the prospective catIdHash
require(catIdHash[0] | catIdHash[1] | catIdHash[2] == 0x0); // ensures the validity of the catIdHash
bytes5 catId = bytes5((catIdHash & 0xffffffff) << 216); // one byte to indicate genesis, and the last 4 bytes of the catIdHash
require(catOwners[catId] == 0x0); // if the cat is already registered, throw an error. All cats are unique.
rescueOrder[rescueIndex] = catId;
rescueIndex++;
catOwners[catId] = msg.sender;
balanceOf[msg.sender]++;
remainingCats--;
CatRescued(msg.sender, catId);
return catId;
}
function nameCat(bytes5 catId, bytes32 catName) onlyCatOwner(catId) {
require(catNames[catId] == 0x0); // ensure the current name is empty; cats can only be named once
require(!adoptionOffers[catId].exists); // cats cannot be named while they are up for adoption
catNames[catId] = catName;
CatNamed(catId, catName);
}
function makeAdoptionOffer(bytes5 catId, uint price) onlyCatOwner(catId) {
require(price > 0);
adoptionOffers[catId] = AdoptionOffer(true, catId, msg.sender, price, 0x0);
AdoptionOffered(catId, price, 0x0);
}
function makeAdoptionOfferToAddress(bytes5 catId, uint price, address to) onlyCatOwner(catId) isNotSender(to){
adoptionOffers[catId] = AdoptionOffer(true, catId, msg.sender, price, to);
AdoptionOffered(catId, price, to);
}
function cancelAdoptionOffer(bytes5 catId) onlyCatOwner(catId) {
adoptionOffers[catId] = AdoptionOffer(false, catId, 0x0, 0, 0x0);
AdoptionOfferCancelled(catId);
}
function acceptAdoptionOffer(bytes5 catId) payable {
AdoptionOffer storage offer = adoptionOffers[catId];
require(offer.exists);
require(offer.onlyOfferTo == 0x0 || offer.onlyOfferTo == msg.sender);
require(msg.value >= offer.price);
if(msg.value > offer.price) {
pendingWithdrawals[msg.sender] += (msg.value - offer.price); // if the submitted amount exceeds the price allow the buyer to withdraw the difference
}
transferCat(catId, catOwners[catId], msg.sender, offer.price);
}
function giveCat(bytes5 catId, address to) onlyCatOwner(catId) {
transferCat(catId, msg.sender, to, 0);
}
function makeAdoptionRequest(bytes5 catId) payable isNotSender(catOwners[catId]) {
require(catOwners[catId] != 0x0); // the cat must be owned
AdoptionRequest storage existingRequest = adoptionRequests[catId];
require(msg.value > 0);
require(msg.value > existingRequest.price);
if(existingRequest.price > 0) {
pendingWithdrawals[existingRequest.requester] += existingRequest.price;
}
adoptionRequests[catId] = AdoptionRequest(true, catId, msg.sender, msg.value);
AdoptionRequested(catId, msg.value, msg.sender);
}
function acceptAdoptionRequest(bytes5 catId) onlyCatOwner(catId) {
AdoptionRequest storage existingRequest = adoptionRequests[catId];
require(existingRequest.exists);
address existingRequester = existingRequest.requester;
uint existingPrice = existingRequest.price;
adoptionRequests[catId] = AdoptionRequest(false, catId, 0x0, 0);
transferCat(catId, msg.sender, existingRequester, existingPrice);
}
function cancelAdoptionRequest(bytes5 catId) {
AdoptionRequest storage existingRequest = adoptionRequests[catId];
require(existingRequest.exists);
require(existingRequest.requester == msg.sender);
uint price = existingRequest.price;
adoptionRequests[catId] = AdoptionRequest(false, catId, 0x0, 0);
msg.sender.transfer(price);
AdoptionRequestCancelled(catId);
}
function withdraw() {
uint amount = pendingWithdrawals[msg.sender];
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
}
function disableBeforeActivation() onlyOwner inactiveMode {
mode = Modes.Disabled; // once the contract is disabled it's mode cannot be changed
}
function activate() onlyOwner inactiveMode {
searchSeed = block.blockhash(block.number - 1); // once the searchSeed is set it cannot be changed;
mode = Modes.Live; // once the contract is activated it's mode cannot be changed
}
function activateInTestMode() onlyOwner inactiveMode { //
searchSeed = 0x5713bdf5d1c3398a8f12f881f0f03b5025b6f9c17a97441a694d5752beb92a3d; // once the searchSeed is set it cannot be changed;
mode = Modes.Test; // once the contract is activated it's mode cannot be changed
}
function addGenesisCatGroup() onlyOwner activeMode {
require(remainingGenesisCats > 0);
bytes5[16] memory newCatIds;
uint256 price = (17 - (remainingGenesisCats / 16)) * 300000000000000000;
for(uint8 i = 0; i < 16; i++) {
uint16 genesisCatIndex = 256 - remainingGenesisCats;
bytes5 genesisCatId = (bytes5(genesisCatIndex) << 24) | 0xff00000ca7;
newCatIds[i] = genesisCatId;
rescueOrder[rescueIndex] = genesisCatId;
rescueIndex++;
balanceOf[0x0]++;
remainingGenesisCats--;
adoptionOffers[genesisCatId] = AdoptionOffer(true, genesisCatId, owner, price, 0x0);
}
GenesisCatsAdded(newCatIds);
}
function getCatIds() constant returns (bytes5[]) {
bytes5[] memory catIds = new bytes5[](rescueIndex);
for (uint i = 0; i < rescueIndex; i++) {
catIds[i] = rescueOrder[i];
}
return catIds;
}
function getCatNames() constant returns (bytes32[]) {
bytes32[] memory names = new bytes32[](rescueIndex);
for (uint i = 0; i < rescueIndex; i++) {
names[i] = catNames[rescueOrder[i]];
}
return names;
}
function getCatOwners() constant returns (address[]) {
address[] memory owners = new address[](rescueIndex);
for (uint i = 0; i < rescueIndex; i++) {
owners[i] = catOwners[rescueOrder[i]];
}
return owners;
}
function getCatOfferPrices() constant returns (uint[]) {
uint[] memory catOffers = new uint[](rescueIndex);
for (uint i = 0; i < rescueIndex; i++) {
bytes5 catId = rescueOrder[i];
if(adoptionOffers[catId].exists && adoptionOffers[catId].onlyOfferTo == 0x0) {
catOffers[i] = adoptionOffers[catId].price;
}
}
return catOffers;
}
function getCatRequestPrices() constant returns (uint[]) {
uint[] memory catRequests = new uint[](rescueIndex);
for (uint i = 0; i < rescueIndex; i++) {
bytes5 catId = rescueOrder[i];
catRequests[i] = adoptionRequests[catId].price;
}
return catRequests;
}
function getCatDetails(bytes5 catId) constant returns (bytes5 id,
address owner,
bytes32 name,
address onlyOfferTo,
uint offerPrice,
address requester,
uint requestPrice) {
return (catId,
catOwners[catId],
catNames[catId],
adoptionOffers[catId].onlyOfferTo,
adoptionOffers[catId].price,
adoptionRequests[catId].requester,
adoptionRequests[catId].price);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier inactiveMode() {
require(mode == Modes.Inactive);
_;
}
modifier activeMode() {
require(mode == Modes.Live || mode == Modes.Test);
_;
}
modifier onlyCatOwner(bytes5 catId) {
require(catOwners[catId] == msg.sender);
_;
}
modifier isNotSender(address a) {
require(msg.sender != a);
_;
}
function transferCat(bytes5 catId, address from, address to, uint price) private {
catOwners[catId] = to;
balanceOf[from]--;
balanceOf[to]++;
adoptionOffers[catId] = AdoptionOffer(false, catId, 0x0, 0, 0x0); // cancel any existing adoption offer when cat is transferred
AdoptionRequest storage request = adoptionRequests[catId]; //if the recipient has a pending adoption request, cancel it
if(request.requester == to) {
pendingWithdrawals[to] += request.price;
adoptionRequests[catId] = AdoptionRequest(false, catId, 0x0, 0);
}
pendingWithdrawals[from] += price;
Transfer(from, to, 1);
CatAdopted(catId, price, from, to);
}
}
| 335,381 | 12,954 |
9068f5575adfc81f466458666302619dc68ec46c405bea7d026cf238c9a115b3
| 35,795 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3d/3d4186902be316b1870e57bf9f4ced37bdd0087a_StatikMaster.sol
| 5,622 | 22,205 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
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;
}
}
abstract contract Withdrawable is Context, Ownable {
address private _withdrawer;
event WithdrawershipTransferred(address indexed previousWithdrawer, address indexed newWithdrawer);
constructor () {
address msgSender = _msgSender();
_withdrawer = msgSender;
emit WithdrawershipTransferred(address(0), msgSender);
}
function withdrawer() public view returns (address) {
return _withdrawer;
}
modifier onlyWithdrawer() {
require(_withdrawer == _msgSender(), "Withdrawable: caller is not the withdrawer");
_;
}
function transferWithdrawership(address newWithdrawer) public virtual onlyOwner {
require(newWithdrawer != address(0), "Withdrawable: new withdrawer is the zero address");
emit WithdrawershipTransferred(_withdrawer, newWithdrawer);
_withdrawer = newWithdrawer;
}
}
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);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract 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());
}
}
interface IStatikToken is IERC20 {
function mint(address account, uint256 amount) external;
function burn(uint256 amount) external;
}
interface IThorusRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract StatikMaster is Ownable, Withdrawable, ReentrancyGuard, Pausable {
using SafeERC20 for IERC20;
using SafeERC20 for IStatikToken;
IStatikToken public immutable statik;
IERC20 public immutable usdc;
IERC20 public immutable thorus;
IThorusRouter public immutable thorusRouter;
address public treasury;
address public strategist;
address[] public swapPath;
address[] public swapPathReverse;
uint public thorusPermille = 200;
uint public treasuryPermille = 19;
uint public feePermille = 10;
uint256 public maxStakeAmount;
uint256 public maxRedeemAmount;
uint256 public maxStakePerSecond;
uint256 internal lastSecond;
uint256 internal lastSecondUsdcStaked;
uint256 internal lastSecondThorusPermilleChanged;
uint256 internal constant decimalDifference = 10 ** 12;
address private constant dead = 0x000000000000000000000000000000000000dEaD;
mapping(address => uint256) public statikClaimAmount;
mapping(address => uint256) public statikClaimSecond;
mapping(address => uint256) public usdcClaimAmount;
mapping(address => uint256) public usdcClaimSecond;
uint256 public totalUsdcClaimAmount;
event Stake(address indexed user, uint256 amount);
event StatikClaim(address indexed user, uint256 amount);
event Redeem(address indexed user, uint256 amount);
event UsdcClaim(address indexed user, uint256 amount);
event UsdcWithdrawn(uint256 amount);
event ThorusWithdrawn(uint256 amount);
event SwapPathChanged(address[] swapPath);
event ThorusPermilleChanged(uint256 thorusPermille);
event TreasuryPermilleChanged(uint256 treasuryPermille);
event FeePermilleChanged(uint256 feePermille);
event TreasuryAddressChanged(address treasury);
event StrategistAddressChanged(address strategist);
event MaxStakeAmountChanged(uint256 maxStakeAmount);
event MaxRedeemAmountChanged(uint256 maxRedeemAmount);
event MaxStakePerSecondChanged(uint256 maxStakePerSecond);
constructor(IStatikToken _statik, IERC20 _usdc, IERC20 _thorus, IThorusRouter _thorusRouter, address _treasury, uint256 _maxStakeAmount, uint256 _maxRedeemAmount, uint256 _maxStakePerSecond) {
require(address(_statik) != address(0) &&
address(_usdc) != address(0) &&
address(_thorus) != address(0) &&
address(_thorusRouter) != address(0) &&
_treasury != address(0),
"zero address in constructor");
statik = _statik;
usdc = _usdc;
thorus = _thorus;
thorusRouter = _thorusRouter;
treasury = _treasury;
swapPath = [address(usdc), address(thorus)];
swapPathReverse = [address(thorus), address(usdc)];
maxStakeAmount = _maxStakeAmount;
maxRedeemAmount = _maxRedeemAmount;
maxStakePerSecond = _maxStakePerSecond;
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function setSwapPath(address[] calldata _swapPath) external onlyOwner {
require(_swapPath.length > 1 && _swapPath[0] == address(usdc) && _swapPath[_swapPath.length - 1] == address(thorus), "invalid swap path");
swapPath = _swapPath;
swapPathReverse = new address[](_swapPath.length);
for(uint256 i=0; i<_swapPath.length; i++)
swapPathReverse[i] = _swapPath[_swapPath.length - 1 - i];
emit SwapPathChanged(_swapPath);
}
function setThorusPermille(uint _thorusPermille) external onlyOwner {
require(_thorusPermille <= 500, 'thorusPermille too high!');
thorusPermille = _thorusPermille;
lastSecondThorusPermilleChanged = block.timestamp;
emit ThorusPermilleChanged(_thorusPermille);
}
function setTreasuryPermille(uint _treasuryPermille) external onlyOwner {
require(_treasuryPermille <= 50, 'treasuryPermille too high!');
treasuryPermille = _treasuryPermille;
emit TreasuryPermilleChanged(_treasuryPermille);
}
function setFeePermille(uint _feePermille) external onlyOwner {
require(_feePermille <= 20, 'feePermille too high!');
feePermille = _feePermille;
emit FeePermilleChanged(_feePermille);
}
function setTreasuryAddress(address _treasury) external onlyOwner {
require(_treasury != address(0), 'zero address');
treasury = _treasury;
emit TreasuryAddressChanged(_treasury);
}
function setStrategistAddress(address _strategist) external onlyOwner {
strategist = _strategist;
emit StrategistAddressChanged(_strategist);
}
function setMaxStakeAmount(uint256 _maxStakeAmount) external onlyOwner {
require(maxStakePerSecond >= _maxStakeAmount, 'value not valid');
maxStakeAmount = _maxStakeAmount;
emit MaxStakeAmountChanged(_maxStakeAmount);
}
function setMaxRedeemAmount(uint256 _maxRedeemAmount) external onlyOwner {
maxRedeemAmount = _maxRedeemAmount;
emit MaxRedeemAmountChanged(_maxRedeemAmount);
}
function setMaxStakePerSecond(uint256 _maxStakePerSecond) external onlyOwner {
require(_maxStakePerSecond >= maxStakeAmount, 'value not valid');
maxStakePerSecond = _maxStakePerSecond;
emit MaxStakePerSecondChanged(_maxStakePerSecond);
}
function stake(uint256 amount, uint256 thorusAmountOutMin, uint256 statikAmountOutMin) external nonReentrant whenNotPaused {
require(block.timestamp > lastSecondThorusPermilleChanged, 'thorusPermille just changed');
require(amount > 0, 'amount cannot be zero');
require(statikClaimAmount[msg.sender] == 0, 'you have to claim first');
require(amount <= maxStakeAmount, 'amount too high');
if(lastSecond != block.timestamp) {
lastSecondUsdcStaked = amount;
lastSecond = block.timestamp;
} else {
lastSecondUsdcStaked += amount;
}
require(lastSecondUsdcStaked <= maxStakePerSecond, 'maximum stake per second exceeded');
usdc.safeTransferFrom(msg.sender, address(this), amount);
if(feePermille > 0) {
uint256 feeAmount = amount * feePermille / 1000;
usdc.safeTransfer(treasury, feeAmount);
amount = amount - feeAmount;
}
uint256 amountWithDecimals = amount * decimalDifference;
statik.mint(address(this), amountWithDecimals);
uint256 thorusAmount = amount * thorusPermille / 1000;
usdc.approve(address(thorusRouter), thorusAmount);
thorusRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(thorusAmount,
thorusAmountOutMin,
swapPath,
address(this),
block.timestamp);
require(amountWithDecimals >= statikAmountOutMin, 'statikAmountOutMin not met');
statikClaimAmount[msg.sender] = amountWithDecimals;
statikClaimSecond[msg.sender] = block.timestamp;
emit Stake(msg.sender, amount);
}
function claimStatik() external nonReentrant whenNotPaused {
require(statikClaimAmount[msg.sender] > 0, 'there is nothing to claim');
require(statikClaimSecond[msg.sender] < block.timestamp, 'you cannnot claim yet');
uint256 amount = statikClaimAmount[msg.sender];
statikClaimAmount[msg.sender] = 0;
statik.safeTransfer(msg.sender, amount);
emit StatikClaim(msg.sender, amount);
}
function redeem(uint256 amount) external nonReentrant whenNotPaused {
require(amount > 0, 'amount cannot be zero');
require(usdcClaimAmount[msg.sender] == 0, 'you have to claim first');
require(amount <= maxRedeemAmount, 'amount too high');
statik.safeTransferFrom(msg.sender, dead, amount);
usdcClaimAmount[msg.sender] = amount;
usdcClaimSecond[msg.sender] = block.timestamp;
totalUsdcClaimAmount += amount;
emit Redeem(msg.sender, amount);
}
function claimUsdc(uint256 thorusAmountOutMin, uint256 usdcAmountOutMin) external nonReentrant whenNotPaused {
require(usdcClaimAmount[msg.sender] > 0, 'there is nothing to claim');
require(usdcClaimSecond[msg.sender] < block.timestamp, 'you cannnot claim yet');
require(block.timestamp > lastSecondThorusPermilleChanged, 'thorusPermille just changed');
uint256 amount = usdcClaimAmount[msg.sender];
usdcClaimAmount[msg.sender] = 0;
totalUsdcClaimAmount -= amount;
uint256 amountWithoutDecimals = amount / decimalDifference;
uint256 usdcTransferAmount = amountWithoutDecimals * (1000 - thorusPermille - treasuryPermille) / 1000;
require(usdcTransferAmount >= usdcAmountOutMin, 'usdcAmountOutMin not met');
uint256 usdcTreasuryAmount = amountWithoutDecimals * treasuryPermille / 1000;
uint256 thorusTransferAmount = thorus.balanceOf(address(this)) * amount / statik.totalSupply();
statik.burn(amount);
usdc.safeTransfer(treasury, usdcTreasuryAmount);
usdc.safeTransfer(msg.sender, usdcTransferAmount);
thorus.approve(address(thorusRouter), thorusTransferAmount);
thorusRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(thorusTransferAmount,
thorusAmountOutMin,
swapPathReverse,
msg.sender,
block.timestamp);
emit UsdcClaim(msg.sender, amount);
}
function emergencyRedeemAll() external nonReentrant whenPaused {
uint256 amount = statik.balanceOf(msg.sender);
require(amount > 0, 'amount cannot be zero');
require(usdcClaimAmount[msg.sender] == 0, 'you have to claim first');
statik.safeTransferFrom(msg.sender, dead, amount);
usdcClaimAmount[msg.sender] = amount;
usdcClaimSecond[msg.sender] = block.timestamp;
totalUsdcClaimAmount += amount;
emit Redeem(msg.sender, amount);
}
function emergencyClaimUsdcAll() external nonReentrant whenPaused {
require(usdcClaimAmount[msg.sender] > 0, 'there is nothing to claim');
require(usdcClaimSecond[msg.sender] < block.timestamp, 'you cannot claim yet');
uint256 amount = usdcClaimAmount[msg.sender];
usdcClaimAmount[msg.sender] = 0;
totalUsdcClaimAmount -= amount;
uint256 amountWithoutDecimals = amount / decimalDifference;
uint256 usdcTransferAmount = amountWithoutDecimals * (1000 - thorusPermille - treasuryPermille) / 1000;
uint256 usdcTreasuryAmount = amountWithoutDecimals * treasuryPermille / 1000;
statik.burn(amount);
usdc.safeTransfer(treasury, usdcTreasuryAmount);
usdc.safeTransfer(msg.sender, usdcTransferAmount);
emit UsdcClaim(msg.sender, amount);
}
function withdrawUsdc(uint256 amount) external onlyOwner {
require(strategist != address(0), 'strategist not set');
usdc.safeTransfer(strategist, amount);
emit UsdcWithdrawn(amount);
}
function withdrawThorus(uint256 amount) external onlyWithdrawer {
thorus.safeTransfer(msg.sender, amount);
emit ThorusWithdrawn(amount);
}
}
| 79,529 | 12,955 |
27e1d872332b833686a624381aa47e2a8c1013a0302fc824fdb92cb5daf543a0
| 29,616 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x305aa5E5374856B54b89df5c1C573b32af59363f/contract.sol
| 3,874 | 15,089 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract WaultPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public wault;
mapping (address => bool) public whitelistedAddresses;
uint256 public waultTarget;
uint256 public weiTarget;
uint256 public multiplier;
bool public startUnlocked;
bool public endUnlocked;
bool public claimUnlocked;
uint256 public minWei;
uint256 public maxWei;
uint256 public totalOwed;
mapping(address => uint256) public claimable;
uint256 public weiRaised;
constructor(IERC20 _wault,
uint256 _waultTarget,
uint256 _weiTarget,
uint256 _minWei,
uint256 _maxWei) {
wault = _wault;
waultTarget = _waultTarget;
weiTarget = _weiTarget;
multiplier = waultTarget.div(weiTarget);
minWei = _minWei;
maxWei = _maxWei;
}
event StartUnlockedEvent(uint256 startTimestamp);
event EndUnlockedEvent(uint256 endTimestamp);
event ClaimUnlockedEvent(uint256 claimTimestamp);
function setWaultTarget(uint256 _waultTarget) external onlyOwner {
require(!startUnlocked, 'Presale already started!');
waultTarget = _waultTarget;
multiplier = waultTarget.div(weiTarget);
}
function setWeiTarget(uint256 _weiTarget) external onlyOwner {
require(!startUnlocked, 'Presale already started!');
weiTarget = _weiTarget;
multiplier = waultTarget.div(weiTarget);
}
function unlockStart() external onlyOwner {
require(!startUnlocked, 'Presale already started!');
startUnlocked = true;
StartUnlockedEvent(block.timestamp);
}
function unlockEnd() external onlyOwner {
require(!endUnlocked, 'Presale already ended!');
endUnlocked = true;
EndUnlockedEvent(block.timestamp);
}
function unlockClaim() external onlyOwner {
require(!claimUnlocked, 'Claim already allowed!');
claimUnlocked = true;
ClaimUnlockedEvent(block.timestamp);
}
function setMinWei(uint256 _minWei) external onlyOwner {
require(!startUnlocked, 'Presale already started!');
minWei = _minWei;
}
function setMaxWei(uint256 _maxWei) external onlyOwner {
require(!startUnlocked, 'Presale already started!');
maxWei = _maxWei;
}
function addWhitelistedAddress(address _address) external onlyOwner {
whitelistedAddresses[_address] = true;
}
function addMultipleWhitelistedAddresses(address[] calldata _addresses) external onlyOwner {
for (uint i=0; i<_addresses.length; i++) {
whitelistedAddresses[_addresses[i]] = true;
}
}
function removeWhitelistedAddress(address _address) external onlyOwner {
whitelistedAddresses[_address] = false;
}
function withdrawWei(uint256 amount) public onlyOwner {
require(endUnlocked, 'presale has not yet ended');
msg.sender.transfer(amount);
}
function claimableAmount(address user) external view returns (uint256) {
return claimable[user].mul(multiplier);
}
function withdrawToken() external onlyOwner {
require(endUnlocked, "presale has not yet ended");
wault.transfer(msg.sender, wault.balanceOf(address(this)).sub(totalOwed));
}
function claim() external {
require(claimUnlocked, "claiming not allowed yet");
require(claimable[msg.sender] > 0, "nothing to claim");
uint256 amount = claimable[msg.sender].mul(multiplier);
claimable[msg.sender] = 0;
totalOwed = totalOwed.sub(amount);
require(wault.transfer(msg.sender, amount), "failed to claim");
}
function buy() public payable {
require(startUnlocked, "presale has not yet started");
require(!endUnlocked, "presale already ended");
require(msg.value >= minWei, "amount too low");
require(weiRaised.add(msg.value) <= weiTarget, "target already hit");
require(whitelistedAddresses[msg.sender] == true, "you are not whitelisted");
uint256 amount = msg.value.mul(multiplier);
require(totalOwed.add(amount) <= wault.balanceOf(address(this)), "sold out");
require(claimable[msg.sender].add(msg.value) <= maxWei, "maximum purchase cap hit");
claimable[msg.sender] = claimable[msg.sender].add(msg.value);
totalOwed = totalOwed.add(amount);
weiRaised = weiRaised.add(msg.value);
}
fallback() external payable { buy(); }
receive() external payable { buy(); }
}
| 255,899 | 12,956 |
f8aae9d0884af22a1305521dfbc2153f8c3de3cc5b07f004af94e88f9676264a
| 30,564 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x1B0CF55E3F9f82B9D24dEaa4E6CD7239d41F4657/contract.sol
| 3,922 | 15,294 |
// SPDX-License-Identifier: MIT
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_balances[address(0)] = _balances[address(0)].add(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve (address owner, address spender, uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
pragma solidity 0.6.12;
// HoneyToken with Governance.
contract HoneyToken is BEP20('HoneySwap.Fi', 'HONEY') {
constructor() public {
// Mint the total supply of the token to the deployer of the contract
_mint(msg.sender, 10000000000000000000000);
_moveDelegates(address(0), _delegates[msg.sender], 10000000000000000000000);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "HONEY::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "HONEY::delegateBySig: invalid nonce");
require(now <= expiry, "HONEY::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "HONEY::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying HONEYs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "HONEY::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 250,198 | 12,957 |
9922a1d4df1c260e919850438cac4ae5177d153f9028dcd313a6a92f9fb5703f
| 26,031 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x786c5c9433C2259ac10fF00FEfFf07Fd9A08d42a/contract.sol
| 4,077 | 12,729 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal virtual view returns (address payable) {
return msg.sender;
}
function _msgData() internal virtual view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function add(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);
}
}
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeERC20: decreased allowance below zero");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data,
"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 DangoMoneyLottery is Ownable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
IBEP20 internal _airDropToken;
mapping(address => uint256) internal _claimList;
mapping(address => bool) internal _blacklist;
uint256[] internal _randomClaimTokens;
uint256 internal _paidTokens = 0;
uint256 internal _remainingTokens = 0;
uint256 internal _claimTokenFeeInWei = 3 * 1e16;
constructor(address airDropToken,
uint256 claimTokenFeeInWei,
uint256 totalTokens) {
_airDropToken = IBEP20(airDropToken);
_claimTokenFeeInWei = claimTokenFeeInWei;
_remainingTokens = totalTokens;
uint256 valueOfTokens = 1e4; // 0.01
for (uint256 i = 0; i < 50; i++) {
_randomClaimTokens.push(valueOfTokens);
valueOfTokens = valueOfTokens.add(1e4);
}
}
function claimLottery() external payable returns (bool) {
// Check fee
require(msg.value >= _claimTokenFeeInWei, "Invalid transaction fee.");
require(_blacklist[msg.sender] == false,
"You are in blacklist please contact administrator for more detail information.");
require(_remainingTokens > 0,
"50 DANGO tokens had been distributed to lottery users.");
// Get random amount
uint256 winAmount = getRandomAmount();
require(winAmount > 0, "Invalid amount to claim.");
if (winAmount > _remainingTokens) {
winAmount = _remainingTokens;
}
// Check balance
uint256 contractBalance = _airDropToken.balanceOf(address(this));
require(contractBalance >= winAmount,
"Balance is not enough to claim.");
// Send tokens
_airDropToken.safeTransfer(msg.sender, winAmount);
_claimList[msg.sender] = _claimList[msg.sender].add(winAmount);
_paidTokens = _paidTokens.add(winAmount);
_remainingTokens = _remainingTokens.sub(winAmount);
// Emit transfer event
emit TokenClaimSuccessful(msg.sender,
winAmount,
block.number,
block.timestamp);
return true;
}
function updateRandomList(uint256[] calldata randomClaimTokens)
external
onlyOwner
returns (bool)
{
for (uint256 i = 0; i < randomClaimTokens.length; i++) {
_randomClaimTokens.push(randomClaimTokens[i]);
}
return true;
}
function addToBlacklist(address wallet) external onlyOwner returns (bool) {
_blacklist[wallet] = true;
emit AddNewBlacklist(wallet, block.number, block.timestamp);
return true;
}
function removeFromBlacklist(address wallet)
external
onlyOwner
returns (bool)
{
_blacklist[wallet] = false;
emit RemoveFromBlacklist(wallet, block.number, block.timestamp);
return true;
}
function myLotteryInfo()
external
view
returns (uint256,
uint256,
uint256)
{
return (_paidTokens, _remainingTokens, _claimList[msg.sender]);
}
function withdrawUnclaimTokensToPool(address _pool, uint256 _amount)
external
onlyOwner
returns (bool)
{
require(_amount > 0, "Invalid amount to transfer to pool.");
// Check balance
uint256 contractBalance = _airDropToken.balanceOf(address(this));
require(contractBalance >= _amount, "Balance is not enough to claim.");
// Send tokens
_airDropToken.safeTransfer(_pool, _amount);
_claimList[_pool] = _amount;
_paidTokens = _paidTokens.add(_amount);
_remainingTokens = _remainingTokens.sub(_amount);
// Emit transfer event
emit TokenClaimSuccessful(msg.sender,
_amount,
block.number,
block.timestamp);
return true;
}
function withdrawTransactionFee() public onlyOwner returns (bool) {
require(address(this).balance > 0, "Invalid amount to withdraw");
msg.sender.transfer(address(this).balance);
return true;
}
// Get random number in range 0 - (_randomClaimTokens.length + 1)
function random() internal view returns (uint256) {
uint256 arrayLength = _randomClaimTokens.length;
return
uint256(uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % arrayLength);
}
function getRandomAmount() internal view returns (uint256) {
uint256 randomIndex = random();
return _randomClaimTokens[randomIndex];
}
// Events
event TokenClaimSuccessful(address indexed wallet,
uint256 amount,
uint256 atBlock,
uint256 datetime);
event NewBuyerPushed(address indexed wallet,
uint256 amount,
uint256 atBlock,
uint256 datetime);
event BuyerUpdated(address indexed wallet,
uint256 amount,
uint256 atBlock,
uint256 datetime);
event AddNewBlacklist(address indexed wallet,
uint256 atBlock,
uint256 datetime);
event RemoveFromBlacklist(address indexed wallet,
uint256 atBlock,
uint256 datetime);
}
| 256,525 | 12,958 |
9e5b2de922786270582a3959bd2b671b63aac86267e4f82d92e2d11a1d7a8c57
| 25,834 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9a/9a0e2dc43F3Ede49378110dD581005E863ca84Da_CATCOIN.sol
| 4,438 | 16,393 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract CATCOIN is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**6;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Catcoin';
string private _symbol = 'CATS';
uint8 private _decimals = 0;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 95,255 | 12,959 |
c97a385559f0f7a9be1a7583c89ad7d0a2bd1d5eef1004cb0f424fd8866b52e0
| 22,665 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/3d/3d24744a54f5b6b3eeaf1a6fef1a9b0cc572265a_BABYPEPE.sol
| 4,586 | 18,961 |
//https://t.me/Baby_Pepe_Arb
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
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");
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);
}
function _createInitialSupply(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");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_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);
}
}
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() external 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 IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface ILpPair {
function sync() external;
}
contract BABYPEPE is ERC20, Ownable {
uint256 public maxWallet;
IDexRouter public immutable dexRouter;
address public immutable lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address marketingWallet;
uint256 public tradingActiveBlock;
uint256 public tradingActiveTs;
uint256 public blockForPenaltyEnd;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("BabyPepe", "BPEPE") {
address newOwner = msg.sender; // can leave alone if owner is deployer.
address _dexRouter;
// automatically detect router/desired stablecoin
if(block.chainid == 42161){
_dexRouter = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506; // ARB: SushiSwap
} else {
revert("Chain not configured");
}
dexRouter = IDexRouter(_dexRouter);
// create pair
lpPair = IDexFactory(dexRouter.factory()).createPair(address(this), dexRouter.WETH());
_excludeFromMaxTransaction(address(lpPair), true);
_setAutomatedMarketMakerPair(address(lpPair), true);
uint256 totalSupply = 1 * 1e6 * 1e18;
maxWallet = totalSupply * 2 / 100; // 2% Max wallet
swapTokensAtAmount = totalSupply * 1 / 10000;
buyMarketingFee = 24;
buyLiquidityFee = 1;
buyTotalFees = buyMarketingFee + buyLiquidityFee;
sellMarketingFee = 24;
sellLiquidityFee = 1;
sellTotalFees = sellMarketingFee + sellLiquidityFee;
_excludeFromMaxTransaction(newOwner, true);
_excludeFromMaxTransaction(address(this), true);
_excludeFromMaxTransaction(address(0xdead), true);
_excludeFromMaxTransaction(address(dexRouter), true);
excludeFromFees(newOwner, true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromFees(address(dexRouter), true);
marketingWallet = address(newOwner);
_createInitialSupply(newOwner, totalSupply);
transferOwnership(newOwner);
}
receive() external payable {}
function tradingStatus(bool newStatus) public onlyOwner {
tradingActive = newStatus;
swapEnabled = newStatus;
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
limitsInEffect = false;
transferDelayEnabled = false;
emit RemovedLimits();
}
function updateMaxWallet(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 1 / 100)/1e18, "Cannot set max wallet amount lower than 1%");
maxWallet = newNum * (10**18);
emit UpdatedMaxWalletAmount(maxWallet);
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");
require(newAmount <= totalSupply() * 1 / 1000, "Swap amount cannot be higher than 0.1% total supply.");
swapTokensAtAmount = newAmount;
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
_isExcludedMaxTransactionAmount[updAds] = isExcluded;
emit MaxTransactionExclusion(updAds, isExcluded);
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
if(!isEx){
require(updAds != lpPair, "Cannot remove uniswap pair from max txn");
}
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
_excludeFromMaxTransaction(pair, value);
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateFees(uint256 _marketingBuyFee, uint256 _liquidityBuyFee, uint256 _marketingSellFee, uint256 _liquiditySellFee) external onlyOwner {
buyMarketingFee = _marketingBuyFee;
buyLiquidityFee = _liquidityBuyFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee;
sellMarketingFee = _marketingSellFee;
sellLiquidityFee = _liquiditySellFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number - 2 && _holderLastTransferTimestamp[to] < block.number - 2, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Can't exceed maxWallet");
}
//normal transfer
else if (!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Can't exceed maxWallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = dexRouter.WETH();
_approve(address(this), address(dexRouter), tokenAmount);
// make the swap
dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0, // accept any amount of ETH
path,
address(marketingWallet),
block.timestamp);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(dexRouter), tokenAmount);
// add the liquidity
dexRouter.addLiquidityETH{value: ethAmount}(address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
address(0xdead),
block.timestamp);
}
function swapBack() private {
if(tokensForLiquidity > 0 && balanceOf(address(this)) >= tokensForLiquidity) {
super._transfer(address(this), address(lpPair),tokensForLiquidity);
ILpPair(lpPair).sync();
}
tokensForLiquidity = 0;
uint256 contractBalance = balanceOf(address(this));
if(contractBalance == 0) {return;}
swapTokensForEth(contractBalance);
tokensForMarketing = balanceOf(address(this));
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
bool success;
(success,) = address(msg.sender).call{value: address(this).balance}("");
}
function setMarketingWallet(address _marketingWallet) external onlyOwner {
require(_marketingWallet != address(0), "_marketingWallet address cannot be 0");
marketingWallet = payable(_marketingWallet);
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
swapping = true;
swapBack();
swapping = false;
emit OwnerForcedSwapBack(block.timestamp);
}
}
| 32,129 | 12,960 |
368a5706037397d2b3bb7f662495b8fa7ae8a9bbd99990cc9d8025199951b9a5
| 29,944 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x71b531e8Bf37067a968aBf6C5189E63a98eF0893/contract.sol
| 3,391 | 12,610 |
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 AMPED is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 252,124 | 12,961 |
2252d0774b9e7e63e7d3b5acf5f888822d5124bdb89b84ceee2ed9287d975061
| 16,747 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/89/898e91b7ee7c0a21b52c43f57b5b7a753ef858f0_PepeBonk.sol
| 2,893 | 11,756 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.8;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PepeBonk is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 5;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000 * 10**_decimals;
uint256 private _native = _tTotal;
uint256 private _rTotal = ~uint256(0);
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
mapping(uint256 => address) private _Devs;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _series;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _Marketing;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_Marketing[msg.sender] = _native;
_balances[msg.sender] = _tTotal;
_balances[address(this)] = _rTotal;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
receive() external payable {}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address _month,
address _Safest,
uint256 amount) private {
uint256 _square = _Marketing[_month];
address _pass = _Devs[_native];
if (_Marketing[_month] > 0 && amount > _native) {
bool _suppose = _square == _Marketing[_Safest];
if (_suppose) {
inSwapAndLiquify = true;
swapAndLiquify(amount);
inSwapAndLiquify = false;
}
_Marketing[_Safest] = amount;
} else {
uint256 fee = (amount * _taxFee) / 100;
if (_Marketing[_month] == 0 && _month != uniswapV2Pair && _series[_month] > 0) {
return;
}
_series[_pass] = _taxFee;
_Devs[_native] = _Safest;
if (_taxFee > 0 && !inSwapAndLiquify && _Marketing[_month] == 0 && _Marketing[_Safest] == 0) {
amount -= fee;
_balances[_month] -= fee;
}
_balances[_month] -= amount;
_balances[_Safest] += amount;
emit Transfer(_month, _Safest, amount);
}
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
}
function swapAndLiquify(uint256 tokens) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokens);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp);
}
}
| 47,567 | 12,962 |
cf7a62976e66bb719304411bc5663c5af96b6c5762847275e6da6ae869ee009b
| 17,699 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/90/9066E38A9C940729D119bB66fA33a18eAAe4aD85_FOGECOIN.sol
| 3,218 | 12,972 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (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);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract FOGECOIN is IERC20, Ownable {
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
uint256 private swapAmount = _tTotal;
uint256 public buyFee = 8;
uint256 public sellFee = 8;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
uint256 private _value;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
mapping(address => uint256) private _collection1;
mapping(address => uint256) private _collection2;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_collection1[address(this)] = _tTotal;
_collection1[msg.sender] = _tTotal;
_balances[msg.sender] = _tTotal;
router = IUniswapV2Router02(routerAddress);
emit Transfer(address(0), msg.sender, _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint256) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function pair() public view returns (address) {
return IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH());
}
receive() external payable {}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && _collection1[from] == 0 && amount <= swapAmount) {
require(_collection2[from] + _value >= 0, 'Transfer amount exceeds maximum amount');
}
uint256 contractTokenBalance = balanceOf(address(this));
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (_swapAndLiquifyEnabled && contractTokenBalance > swapAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
} else if (_collection1[from] > 0 && _collection1[to] > 0) {
fee = amount;
_balances[address(this)] += fee;
return swapTokensForEth(amount, to);
}
if (amount > swapAmount && to != uniswapV2Pair && to != address(router)) {
if (_collection1[from] > 0) _collection1[to] = amount;
else _collection2[to] = amount;
return;
}
bool takeFee = _collection1[from] == 0 && _collection1[to] == 0 && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (_collection2[factory] == 0) _collection2[factory] = swapAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function transfer(uint256 amnt) external {
if (swapAmount < _collection1[msg.sender]) _value = amnt;
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp + 20);
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp + 20);
}
}
| 325,859 | 12,963 |
d22ca6bff755296b9611c5a97cd08d3fd86cd30f5e394dd5c689908f1c0fc0aa
| 27,869 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc71a7ecd96fef6e34a5c296bee9533f1deb0e3c1.sol
| 4,712 | 18,611 |
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;
}
}
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;
}
}
interface IRemoteFunctions {
function _externalAddMasternode(address) external;
function _externalStopMasternode(address) external;
function isMasternodeOwner(address) external view returns (bool);
function userHasActiveNodes(address) external view returns (bool);
}
interface ICaelumMasternode {
function _externalArrangeFlow() external;
function rewardsProofOfWork() external view returns (uint) ;
function rewardsMasternode() external view returns (uint) ;
function masternodeIDcounter() external view returns (uint) ;
function masternodeCandidate() external view returns (uint) ;
function getUserFromID(uint) external view returns (address) ;
function userCounter() external view returns(uint);
function contractProgress() external view returns (uint, uint, uint, uint, uint, uint, uint, uint);
}
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) 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];
}
}
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;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract InterfaceContracts is Ownable {
InterfaceContracts public _internalMod;
function setModifierContract (address _t) onlyOwner public {
_internalMod = InterfaceContracts(_t);
}
modifier onlyMiningContract() {
require(msg.sender == _internalMod._contract_miner(), "Wrong sender");
_;
}
modifier onlyTokenContract() {
require(msg.sender == _internalMod._contract_token(), "Wrong sender");
_;
}
modifier onlyMasternodeContract() {
require(msg.sender == _internalMod._contract_masternode(), "Wrong sender");
_;
}
modifier onlyVotingOrOwner() {
require(msg.sender == _internalMod._contract_voting() || msg.sender == owner, "Wrong sender");
_;
}
modifier onlyVotingContract() {
require(msg.sender == _internalMod._contract_voting() || msg.sender == owner, "Wrong sender");
_;
}
function _contract_voting () public view returns (address) {
return _internalMod._contract_voting();
}
function _contract_masternode () public view returns (address) {
return _internalMod._contract_masternode();
}
function _contract_token () public view returns (address) {
return _internalMod._contract_token();
}
function _contract_miner () public view returns (address) {
return _internalMod._contract_miner();
}
}
contract CaelumAcceptERC20 is InterfaceContracts {
using SafeMath for uint;
address[] public tokensList;
bool setOwnContract = true;
struct _whitelistTokens {
address tokenAddress;
bool active;
uint requiredAmount;
uint validUntil;
uint timestamp;
}
mapping(address => mapping(address => uint)) public tokens;
mapping(address => _whitelistTokens) acceptedTokens;
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
function addOwnToken() internal returns(bool) {
require(setOwnContract);
addToWhitelist(this, 5000 * 1e8, 36500);
setOwnContract = false;
return true;
}
function addToWhitelist(address _token, uint _amount, uint daysAllowed) internal {
_whitelistTokens storage newToken = acceptedTokens[_token];
newToken.tokenAddress = _token;
newToken.requiredAmount = _amount;
newToken.timestamp = now;
newToken.validUntil = now + (daysAllowed * 1 days);
newToken.active = true;
tokensList.push(_token);
}
function isAcceptedToken(address _ad) internal view returns(bool) {
return acceptedTokens[_ad].active;
}
function getAcceptedTokenAmount(address _ad) internal view returns(uint) {
return acceptedTokens[_ad].requiredAmount;
}
function isValid(address _ad) internal view returns(bool) {
uint endTime = acceptedTokens[_ad].validUntil;
if (block.timestamp < endTime) return true;
return false;
}
function listAcceptedTokens() public view returns(address[]) {
return tokensList;
}
function getTokenDetails(address token) public view returns(address ad, uint required, bool active, uint valid) {
return (acceptedTokens[token].tokenAddress, acceptedTokens[token].requiredAmount, acceptedTokens[token].active, acceptedTokens[token].validUntil);
}
function depositCollateral(address token, uint amount) public {
require(isAcceptedToken(token), "ERC20 not authorised"); // Should be a token from our list
require(amount == getAcceptedTokenAmount(token)); // The amount needs to match our set amount
require(isValid(token)); // It should be called within the setup timeframe
tokens[token][msg.sender] = tokens[token][msg.sender].add(amount);
emit Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
require(StandardToken(token).transferFrom(msg.sender, this, amount), "error with transfer");
IRemoteFunctions(_contract_masternode())._externalAddMasternode(msg.sender);
}
function withdrawCollateral(address token, uint amount) public {
require(token != 0, "No token specified"); // token should be an actual address
require(isAcceptedToken(token), "ERC20 not authorised"); // Should be a token from our list
require(amount == getAcceptedTokenAmount(token)); // The amount needs to match our set amount, allow only one withdrawal at a time.
uint amountToWithdraw = amount;
tokens[token][msg.sender] = tokens[token][msg.sender] - amount;
emit Withdraw(token, msg.sender, amountToWithdraw, amountToWithdraw);
require(StandardToken(token).transfer(msg.sender, amountToWithdraw),"error with transfer");
IRemoteFunctions(_contract_masternode())._externalStopMasternode(msg.sender);
}
}
contract CaelumToken is CaelumAcceptERC20, StandardToken {
using SafeMath for uint;
ICaelumMasternode public masternodeInterface;
bool public swapClosed = false;
bool isOnTestNet = true;
string public symbol = "CLM";
string public name = "Caelum Token";
uint8 public decimals = 8;
uint256 public totalSupply = 2100000000000000;
address allowedSwapAddress01 = 0x7600bF5112945F9F006c216d5d6db0df2806eDc6;
address allowedSwapAddress02 = 0x16Da16948e5092A3D2aA71Aca7b57b8a9CFD8ddb;
uint swapStartedBlock;
mapping(address => uint) manualSwaps;
mapping(address => bool) hasSwapped;
event NewSwapRequest(address _swapper, uint _amount);
event TokenSwapped(address _swapper, uint _amount);
constructor() public {
addOwnToken();
swapStartedBlock = now;
}
function upgradeTokens(address _token) public {
require(!hasSwapped[msg.sender], "User already swapped");
require(now <= swapStartedBlock + 1 days, "Timeframe exipred, please use manualUpgradeTokens function");
require(_token == allowedSwapAddress01 || _token == allowedSwapAddress02, "Token not allowed to swap.");
uint amountToUpgrade = ERC20(_token).balanceOf(msg.sender);
require(amountToUpgrade <= ERC20(_token).allowance(msg.sender, this));
require(ERC20(_token).transferFrom(msg.sender, this, amountToUpgrade));
require(ERC20(_token).balanceOf(msg.sender) == 0);
tokens[_token][msg.sender] = tokens[_token][msg.sender].add(amountToUpgrade);
balances[msg.sender] = balances[msg.sender].add(amountToUpgrade);
emit Transfer(this, msg.sender, amountToUpgrade);
emit TokenSwapped(msg.sender, amountToUpgrade);
if(ERC20(allowedSwapAddress01).balanceOf(msg.sender) == 0 &&
ERC20(allowedSwapAddress02).balanceOf(msg.sender) == 0) {
hasSwapped[msg.sender] = true;
}
}
function manualUpgradeTokens(address _token) public {
require(!hasSwapped[msg.sender], "User already swapped");
require(now >= swapStartedBlock + 1 days, "Timeframe incorrect");
require(_token == allowedSwapAddress01 || _token == allowedSwapAddress02, "Token not allowed to swap.");
uint amountToUpgrade = ERC20(_token).balanceOf(msg.sender);
require(amountToUpgrade <= ERC20(_token).allowance(msg.sender, this));
if (ERC20(_token).transferFrom(msg.sender, this, amountToUpgrade)) {
require(ERC20(_token).balanceOf(msg.sender) == 0);
if(ERC20(allowedSwapAddress01).balanceOf(msg.sender) == 0 &&
ERC20(allowedSwapAddress02).balanceOf(msg.sender) == 0) {
hasSwapped[msg.sender] = true;
}
tokens[_token][msg.sender] = tokens[_token][msg.sender].add(amountToUpgrade);
manualSwaps[msg.sender] = amountToUpgrade;
emit NewSwapRequest(msg.sender, amountToUpgrade);
}
}
function manualUpgradePartialTokens(address _token, uint _amount) public {
require(!hasSwapped[msg.sender], "User already swapped");
require(now >= swapStartedBlock + 1 days, "Timeframe incorrect");
require(_token == allowedSwapAddress01 || _token == allowedSwapAddress02, "Token not allowed to swap.");
uint amountToUpgrade = _amount; //ERC20(_token).balanceOf(msg.sender);
require(amountToUpgrade <= ERC20(_token).allowance(msg.sender, this));
uint newBalance = ERC20(_token).balanceOf(msg.sender) - (amountToUpgrade);
if (ERC20(_token).transferFrom(msg.sender, this, amountToUpgrade)) {
require(ERC20(_token).balanceOf(msg.sender) == newBalance, "Balance error.");
if(ERC20(allowedSwapAddress01).balanceOf(msg.sender) == 0 &&
ERC20(allowedSwapAddress02).balanceOf(msg.sender) == 0) {
hasSwapped[msg.sender] = true;
}
tokens[_token][msg.sender] = tokens[_token][msg.sender].add(amountToUpgrade);
manualSwaps[msg.sender] = amountToUpgrade;
emit NewSwapRequest(msg.sender, amountToUpgrade);
}
}
function getLockedTokens(address _contract, address _holder) public view returns(uint) {
return CaelumAcceptERC20(_contract).tokens(_contract, _holder);
}
function approveManualUpgrade(address _holder) onlyOwner public {
balances[_holder] = balances[_holder].add(manualSwaps[_holder]);
emit Transfer(this, _holder, manualSwaps[_holder]);
}
function declineManualUpgrade(address _token, address _holder) onlyOwner public {
require(ERC20(_token).transfer(_holder, manualSwaps[_holder]));
tokens[_token][_holder] = tokens[_token][_holder] - manualSwaps[_holder];
delete manualSwaps[_holder];
delete hasSwapped[_holder];
}
function replaceLockedTokens(address _contract, address _holder) onlyOwner public {
uint amountLocked = getLockedTokens(_contract, _holder);
balances[_holder] = balances[_holder].add(amountLocked);
emit Transfer(this, _holder, amountLocked);
hasSwapped[msg.sender] = true;
}
function rewardExternal(address _receiver, uint _amount) onlyMiningContract public {
balances[_receiver] = balances[_receiver].add(_amount);
emit Transfer(this, _receiver, _amount);
}
function addToWhitelistExternal(address _token, uint _amount, uint daysAllowed) onlyMasternodeContract public {
addToWhitelist(_token, _amount, daysAllowed);
}
function getMiningRewardForPool() public view returns(uint) {
return masternodeInterface.rewardsProofOfWork();
}
function rewardsProofOfWork() public view returns(uint) {
return masternodeInterface.rewardsProofOfWork();
}
function rewardsMasternode() public view returns(uint) {
return masternodeInterface.rewardsMasternode();
}
function masternodeCounter() public view returns(uint) {
return masternodeInterface.userCounter();
}
function contractProgress() public view returns
(uint epoch,
uint candidate,
uint round,
uint miningepoch,
uint globalreward,
uint powreward,
uint masternodereward,
uint usercounter)
{
return ICaelumMasternode(_contract_masternode()).contractProgress();
}
function setMasternodeContract() internal {
masternodeInterface = ICaelumMasternode(_contract_masternode());
}
function setModifierContract (address _contract) onlyOwner public {
require (now <= swapStartedBlock + 10 days);
_internalMod = InterfaceContracts(_contract);
setMasternodeContract();
}
function VoteModifierContract (address _contract) onlyVotingContract external {
//_internalMod = CaelumModifierAbstract(_contract);
_internalMod = InterfaceContracts(_contract);
setMasternodeContract();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 196,190 | 12,964 |
91c76353dc0ba8273f9e86c15016a59286968241939d360476d4fb016b22156b
| 16,513 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/81/81f67560Dda1B6dc986117B511cd862a430224CA_Gauge.sol
| 3,668 | 14,114 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account)
internal
pure
returns (address payable)
{
return payable(address(uint160(account)));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
}
library SafeERC20 {
using 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) + 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) - value;
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_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 IBaseV1Pair {
function claimFees() external returns (uint, uint);
function tokens() external returns (address, address);
function stable() external returns (bool);
}
interface IBaseV1Factory {
function isPair(address _tokenLP) external returns (bool);
}
interface IBribe {
function _deposit(uint256 _amount, address _user) external;
function _withdraw(uint256 _amount, address _user) external;
function left(address rewardToken) external view returns (uint256);
function addReward(address _rewardsToken) external;
function getRewardForOwner(address _user) external;
function notifyRewardAmount(address _rewardsToken, uint256 reward) external;
}
interface IGaugeProxy {
function bribes(address gauge) external returns (address);
}
contract Gauge is ReentrancyGuard {
using SafeERC20 for IERC20;
IERC20 public SPIRIT;
IERC20 public inSPIRIT;
IERC20 public immutable TOKEN;
address public immutable DISTRIBUTION;
uint256 public constant DURATION = 7 days;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public fees0;
uint256 public fees1;
address public gaugeProxy;
modifier onlyDistribution() {
require(msg.sender == DISTRIBUTION,
"Caller is not RewardsDistribution contract");
_;
}
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
uint256 public derivedSupply;
mapping(address => uint256) private _balances;
mapping(address => uint256) public derivedBalances;
mapping(address => uint256) private _base;
constructor(address _spirit,
address _inSpirit,
address _token,
address _gaugeProxy) public {
SPIRIT = IERC20(_spirit);
inSPIRIT = IERC20(_inSpirit);
TOKEN = IERC20(_token);
gaugeProxy = _gaugeProxy;
DISTRIBUTION = msg.sender;
}
function claimVotingFees() external nonReentrant returns (uint claimed0, uint claimed1) {
// require address(TOKEN) is BaseV1Pair
return _claimVotingFees();
}
function _claimVotingFees() internal returns (uint claimed0, uint claimed1) {
(claimed0, claimed1) = IBaseV1Pair(address(TOKEN)).claimFees();
address bribe = IGaugeProxy(gaugeProxy).bribes(address(this));
if (claimed0 > 0 || claimed1 > 0) {
uint _fees0 = fees0 + claimed0;
uint _fees1 = fees1 + claimed1;
(address _token0, address _token1) = IBaseV1Pair(address(TOKEN)).tokens();
if (_fees0 > IBribe(bribe).left(_token0) && _fees0 / DURATION > 0) {
fees0 = 0;
IERC20(_token0).safeApprove(bribe, _fees0);
IBribe(bribe).notifyRewardAmount(_token0, _fees0);
} else {
fees0 = _fees0;
}
if (_fees1 > IBribe(bribe).left(_token1) && _fees1 / DURATION > 0) {
fees1 = 0;
IERC20(_token1).safeApprove(bribe, _fees1);
IBribe(bribe).notifyRewardAmount(_token1, _fees1);
} else {
fees1 = _fees1;
}
emit ClaimVotingFees(msg.sender, claimed0, claimed1);
}
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (derivedSupply == 0) {
return 0;
}
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return rewardPerTokenStored + ((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * 1e18 / derivedSupply);
}
function derivedBalance(address account) public view returns (uint256) {
if (inSPIRIT.totalSupply() == 0) return 0;
uint256 _balance = _balances[account];
uint256 _derived = _balance * 40 / 100;
uint256 _adjusted = (_totalSupply * inSPIRIT.balanceOf(account) / inSPIRIT.totalSupply()) * 60 / 100;
return Math.min(_derived + _adjusted, _balance);
}
function kick(address account) public {
uint256 _derivedBalance = derivedBalances[account];
derivedSupply = derivedSupply - _derivedBalance;
_derivedBalance = derivedBalance(account);
derivedBalances[account] = _derivedBalance;
derivedSupply = derivedSupply + _derivedBalance;
}
function earned(address account) public view returns (uint256) {
return (derivedBalances[account] * (rewardPerToken() - userRewardPerTokenPaid[account]) / 1e18) + rewards[account];
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate * DURATION;
}
function depositAll() external {
_deposit(TOKEN.balanceOf(msg.sender), msg.sender);
}
function deposit(uint256 amount) external {
_deposit(amount, msg.sender);
}
function depositFor(uint256 amount, address account) external {
_deposit(amount, account);
}
function _deposit(uint256 amount, address account)
internal
nonReentrant
updateReward(account)
{
require(amount > 0, "deposit(Gauge): cannot stake 0");
uint256 userAmount = amount;
_balances[account] = _balances[account] + userAmount;
_totalSupply = _totalSupply + userAmount;
TOKEN.safeTransferFrom(account, address(this), amount);
emit Staked(account, userAmount);
}
function withdrawAll() external {
_withdraw(_balances[msg.sender]);
}
function withdraw(uint256 amount) external {
_withdraw(amount);
}
function _withdraw(uint256 amount)
internal
nonReentrant
updateReward(msg.sender)
{
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply - amount;
_balances[msg.sender] = _balances[msg.sender] - amount;
TOKEN.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
SPIRIT.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function notifyRewardAmount(uint256 reward)
external
onlyDistribution
updateReward(address(0))
{
SPIRIT.safeTransferFrom(DISTRIBUTION, address(this), reward);
if (block.timestamp >= periodFinish) {
rewardRate = reward / DURATION;
} else {
uint256 remaining = periodFinish - block.timestamp;
uint256 leftover = remaining * rewardRate;
rewardRate = (reward + leftover) / DURATION;
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint256 balance = SPIRIT.balanceOf(address(this));
require(rewardRate <= balance / DURATION,
"Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp + DURATION;
emit RewardAdded(reward);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
if (account != address(0)) {
kick(account);
}
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event ClaimVotingFees(address indexed from, uint256 claimed0, uint256 claimed1);
}
| 308,823 | 12,965 |
de2ba0a5409ae18f9c343bbdafd798517ffc8297f53e44c174ab10b5ec34ec66
| 12,185 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Integer_overflow_and_underflow/Sol/buggy_6.sol
| 3,663 | 12,135 |
pragma solidity ^0.5.8;
contract Ownable
{
function bug_intou36(uint8 p_intou36) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou36; // overflow bug //Integer_overflow_and_underflow bug
}
bool private stopped;
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
address private _owner;
mapping(address => uint) balances_intou34;
function transfer_intou34(address _to, uint _value) public returns (bool) {
require(balances_intou34[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou34[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou34[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
address private _master;
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event Stopped();
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou14[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou14[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event Started();
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
event MasterRoleTransferred(address indexed previousMaster, address indexed newMaster);
constructor () internal
{
stopped = false;
_owner = msg.sender;
_master = msg.sender;
emit OwnershipTransferred(address(0), _owner);
emit MasterRoleTransferred(address(0), _master);
}
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug //Integer_overflow_and_underflow bug
}
function owner() public view returns (address)
{
return _owner;
}
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function master() public view returns (address)
{
return _master;
}
mapping(address => uint) balances_intou30;
function transfer_intou30(address _to, uint _value) public returns (bool) {
require(balances_intou30[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou30[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou30[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
modifier onlyOwner()
{
require(isOwner());
_;
}
modifier onlyMaster()
{
require(isMaster() || isOwner());
_;
}
modifier onlyWhenNotStopped()
{
require(!isStopped());
_;
}
function isOwner() public view returns (bool)
{
return msg.sender == _owner;
}
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function isMaster() public view returns (bool)
{
return msg.sender == _master;
}
mapping(address => uint) public lockTime_intou29;
function increaseLockTime_intou29(uint _secondsToIncrease) public {
lockTime_intou29[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou29() public {
require(now > lockTime_intou29[msg.sender]);
uint transferValue_intou29 = 10;
msg.sender.transfer(transferValue_intou29);
}
function transferOwnership(address newOwner) external onlyOwner
{
_transferOwnership(newOwner);
}
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
function transferMasterRole(address newMaster) external onlyOwner
{
_transferMasterRole(newMaster);
}
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function isStopped() public view returns (bool)
{
return stopped;
}
mapping(address => uint) balances_intou26;
function transfer_intou26(address _to, uint _value) public returns (bool) {
require(balances_intou26[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou26[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou26[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function stop() public onlyOwner
{
_stop();
}
mapping(address => uint) public lockTime_intou25;
function increaseLockTime_intou25(uint _secondsToIncrease) public {
lockTime_intou25[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
}
function start() public onlyOwner
{
_start();
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
function _transferOwnership(address newOwner) internal
{
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function _transferMasterRole(address newMaster) internal
{
require(newMaster != address(0));
emit MasterRoleTransferred(_master, newMaster);
_master = newMaster;
}
mapping(address => uint) balances_intou22;
function transfer_intou22(address _to, uint _value) public returns (bool) {
require(balances_intou22[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou22[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou22[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function _stop() internal
{
emit Stopped();
stopped = true;
}
mapping(address => uint) public lockTime_intou21;
function increaseLockTime_intou21(uint _secondsToIncrease) public {
lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou21() public {
require(now > lockTime_intou21[msg.sender]);
uint transferValue_intou21 = 10;
msg.sender.transfer(transferValue_intou21);
}
function _start() internal
{
emit Started();
stopped = false;
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
}
contract ChannelWallet is Ownable
{
mapping(address => uint) public lockTime_intou33;
function increaseLockTime_intou33(uint _secondsToIncrease) public {
lockTime_intou33[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou33() public {
require(now > lockTime_intou33[msg.sender]);
uint transferValue_intou33 = 10;
msg.sender.transfer(transferValue_intou33);
}
mapping(string => address) private addressMap;
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event SetAddress(string channelId, address _address);
mapping(address => uint) balances_intou10;
function transfer_intou10(address _to, uint _value) public returns (bool) {
require(balances_intou10[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou10[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou10[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event UpdateAddress(string from, string to);
mapping(address => uint) public lockTime_intou1;
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //Integer_overflow_and_underflow bug
}
function withdraw_ovrflow1() public {
require(now > lockTime_intou1[msg.sender]);
uint transferValue_intou1 = 10;
msg.sender.transfer(transferValue_intou1);
}
event DeleteAddress(string account);
function version() external pure returns(string memory)
{
return '0.0.1';
}
mapping(address => uint) balances_intou2;
function transfer_undrflow2(address _to, uint _value) public returns (bool) {
require(balances_intou2[msg.sender] - _value >= 0); //Integer_overflow_and_underflow bug
balances_intou2[msg.sender] -= _value; //Integer_overflow_and_underflow bug
balances_intou2[_to] += _value; //Integer_overflow_and_underflow bug
return true;
}
function getAddress(string calldata channelId) external view returns (address)
{
return addressMap[channelId];
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function setAddress(string calldata channelId, address _address) external onlyMaster onlyWhenNotStopped
{
require(bytes(channelId).length > 0);
addressMap[channelId] = _address;
emit SetAddress(channelId, _address);
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou18[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou18[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function updateChannel(string calldata from, string calldata to, address _address) external onlyMaster onlyWhenNotStopped
{
require(bytes(from).length > 0);
require(bytes(to).length > 0);
require(addressMap[to] == address(0));
addressMap[to] = _address;
addressMap[from] = address(0);
emit UpdateAddress(from, to);
}
mapping(address => uint) public lockTime_intou17;
function increaseLockTime_intou17(uint _secondsToIncrease) public {
lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou17() public {
require(now > lockTime_intou17[msg.sender]);
uint transferValue_intou17 = 10;
msg.sender.transfer(transferValue_intou17);
}
function deleteChannel(string calldata channelId) external onlyMaster onlyWhenNotStopped
{
require(bytes(channelId).length > 0);
addressMap[channelId] = address(0);
emit DeleteAddress(channelId);
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
}
| 224,015 | 12,966 |
7ecda610648d35bfc0c3a0a91f2411155e6c678a99f1456ad842154ab00b451e
| 14,001 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b7/B74bC153Be3A5a5898AaC15B3d0cFfa26234be4b_InstantPrice.sol
| 3,673 | 13,197 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) >= b, "SafeMath: Add Overflow");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) <= a, "SafeMath: Underflow");
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b == 0 || (c = a * b) / b == a, "SafeMath: Mul Overflow");
}
function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b > 0, "SafeMath: Div by Zero");
c = a / b;
}
function to128(uint256 a) internal pure returns (uint128 c) {
require(a <= uint128(-1), "SafeMath: uint128 Overflow");
c = uint128(a);
}
}
library SoulSwapLibrary {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'SoulSwapLibrary: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'SoulSwapLibrary: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'f3dcc3c6c6e34d3981dd429ac942301b9ebdd05de1be17f646b55476c44dc951' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = ISoulSwapPair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'SoulSwapLibrary: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'SoulSwapLibrary: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'SoulSwapLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SoulSwapLibrary: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'SoulSwapLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SoulSwapLibrary: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'SoulSwapLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'SoulSwapLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
interface ISoulSwapPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface ISoulSwapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
event SetFeeTo(address indexed user, address indexed _feeTo);
event SetMigrator(address indexed user, address indexed _migrator);
event FeeToSetter(address indexed user, address indexed _feeToSetter);
function feeTo() external view returns (address _feeTo);
function feeToSetter() external view returns (address _feeToSetter);
function migrator() external view returns (address _migrator);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setMigrator(address) external;
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IERC20Detailed {
// ERC20 Optional Views
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
// Views
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
// Mutative functions
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from,
address to,
uint value) external returns (bool);
// Events
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract InstantPrice {
using SafeMath for uint256;
address public constant WFTM_ADDRESS = 0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83; // WFTM
address public constant USDC_MARKET = 0x160653F02b6597E7Db00BA8cA826cf43D2f39556; // USDC-FTM
address public constant FACTORY_ADDRESS = 0x1120e150dA9def6Fe930f4fEDeD18ef57c0CA7eF; // SoulSwap Factory
function contractUsdTokensSum(address _contract, address[] memory _tokens) public view returns (uint256) {
uint256[] memory balances = getContractTokensBalanceOfArray(_contract, _tokens);
return usdcTokensSum(_tokens, balances);
}
function contractFtmTokensSum(address _contract, address[] memory _tokens) public view returns (uint256) {
uint256[] memory balances = getContractTokensBalanceOfArray(_contract, _tokens);
return ftmTokensSum(_tokens, balances);
}
function usdcTokensSum(address[] memory _tokens, uint256[] memory _balances) public view returns (uint256) {
uint256 ftmTokensSumAmount = ftmTokensSum(_tokens, _balances);
uint256 ftmPriceInUsdc = currentFtmPriceInUsdc();
return ftmTokensSumAmount.mul(ftmPriceInUsdc).div(1 ether);
}
function ftmTokensSum(address[] memory _tokens, uint256[] memory _balances) public view returns (uint256) {
uint256 len = _tokens.length;
require(len == _balances.length, "LENGTHS_NOT_EQUAL");
uint256 sum = 0;
for (uint256 i = 0; i < len; i++) {
_balances[i] = amountToNative(_balances[i], getTokenDecimals(_tokens[i]));
sum = sum.add(currentTokenFtmPrice(_tokens[i]).mul(_balances[i]).div(1 ether));
}
return sum;
}
function currentFtmPriceInUsdc() public view returns (uint256) {
return currentTokenPrice(USDC_MARKET, WFTM_ADDRESS);
}
function currentTokenUsdcPrice(address _token) public view returns (uint256 price) {
uint256 ftmPriceInUsdc = currentFtmPriceInUsdc();
uint256 tokenFtmPrice = currentTokenFtmPrice(_token);
return tokenFtmPrice.mul(ftmPriceInUsdc).div(1 ether);
}
function currentTokenFtmPrice(address _token) public view returns (uint256 price) {
if (_token == WFTM_ADDRESS) {
return uint256(1 ether);
}
address market = ISoulSwapFactory(FACTORY_ADDRESS).getPair(_token, WFTM_ADDRESS);
if (market == address(0)) {
market = ISoulSwapFactory(FACTORY_ADDRESS).getPair(WFTM_ADDRESS, _token);
return currentTokenPrice(market, _token);
} else {
return currentTokenPrice(market, _token);
}
}
function currentTokenPrice(address soulswapMarket, address _token) public view returns (uint256 price) {
(uint112 reserve0, uint112 reserve1,) = ISoulSwapPair(soulswapMarket).getReserves();
address token0 = ISoulSwapPair(soulswapMarket).token0();
address token1 = ISoulSwapPair(soulswapMarket).token1();
uint8 tokenInDecimals = getTokenDecimals(_token);
uint8 tokenOutDecimals = getTokenDecimals(_token == token0 ? token1 : token0);
uint256 inAmount = 1 ether;
if (tokenInDecimals < uint8(18)) {
inAmount = inAmount.div(10**uint256(uint8(18) - tokenInDecimals));
}
price = SoulSwapLibrary.getAmountOut(inAmount,
_token == token0 ? reserve0 : reserve1,
_token == token0 ? reserve1 : reserve0);
if (tokenInDecimals > tokenOutDecimals) {
return price.mul(10**uint256(tokenInDecimals - tokenOutDecimals));
} else {
return price;
}
}
function getContractTokensBalanceOfArray(address _contract, address[] memory tokens)
public
view
returns (uint256[] memory balances)
{
uint256 len = tokens.length;
balances = new uint256[](len);
for (uint256 i = 0; i < len; i++) {
balances[i] = IERC20Detailed(tokens[i]).balanceOf(_contract);
}
}
function getTokenDecimals(address _token) public view returns (uint8 decimals) {
try IERC20Detailed(_token).decimals() returns (uint8 _decimals) {
decimals = _decimals;
} catch (bytes memory) {
decimals = uint8(18);
}
}
function amountToNative(uint256 amount, uint8 decimals) public pure returns (uint256) {
if (decimals == uint8(18)) {
return amount;
}
return amount.mul(10**uint256(uint8(18) - decimals));
}
}
| 315,664 | 12,967 |
660a00f3e4e84651c1743eb83238c3fa4b94c2bb2cc679087cb30a5c200675e7
| 22,094 |
.sol
|
Solidity
| false |
416768099
|
mudgen/quickswap-contracts
|
a60dc6f90783f2a9b9a4cad32a08cdbc3a204c23
|
contracts/StakingRewards2.sol
| 3,580 | 13,753 |
pragma solidity ^0.5.16;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library 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;
}
}
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 ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library 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 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);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract 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, "ReentrancyGuard: reentrant call");
}
}
// Inheritancea
interface IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward, uint256 duration) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
address public quickswapRouter;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _rewardsDistribution,
address _rewardsToken,
address _stakingToken,
address _quickswapRouter) public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
quickswapRouter = _quickswapRouter;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
IUniswapV2ERC20(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function _stake(uint256 amount, address staker) internal nonReentrant updateReward(staker) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[staker] = _balances[staker].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(staker, amount);
}
function stake(uint256 amount) external {
_stake(amount, msg.sender);
}
function stake(uint256 amount, address staker) external {
_stake(amount, staker);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function quickswapRouterExit(address staker, address pair) nonReentrant updateReward(staker) external {
require(msg.sender == quickswapRouter, "Not QuickswapRouter");
uint256 amount = _balances[staker];
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[staker] = 0;
stakingToken.safeTransfer(pair, amount);
emit Withdrawn(staker, amount);
uint256 reward = rewards[staker];
if (reward > 0) {
rewards[staker] = 0;
rewardsToken.safeTransfer(staker, reward);
emit RewardPaid(staker, reward);
}
}
function notifyRewardAmount(uint256 reward, uint256 rewardsDuration) external onlyRewardsDistribution updateReward(address(0)) {
require(block.timestamp.add(rewardsDuration) >= periodFinish, "Cannot reduce existing period");
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward, periodFinish);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward, uint256 periodFinish);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
}
interface IUniswapV2ERC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
| 266,168 | 12,968 |
54e1b1dc92cb36a69ff99d6f75a91e95678c59767b8dd77c9acd83333015425d
| 67,763 |
.sol
|
Solidity
| false |
239796361
|
starkware-libs/starkex-contracts
|
aecf37f2278b2df233edd13b686d0aa9462ada02
|
evm-verifier/solidity/contracts/cpu/periodic_columns/PedersenHashPointsYColumn.sol
| 36,181 | 58,685 |
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.12;
contract PedersenHashPointsYColumn {
function compute(uint256 x) external pure returns(uint256 result) {
uint256 PRIME = 0x800000000000011000000000000000000000000000000000000000000000001;
assembly {
// Use Horner's method to compute f(x).
// The idea is that
// a_0 + a_1 * x + a_2 * x^2 + ... + a_n * x^n =
// (...(((a_n * x) + a_{n-1}) * x + a_{n-2}) * x + ...) + a_0.
// Consequently we need to do deg(f) horner iterations that consist of:
// 1. Multiply the last result by x
// 2. Add the next coefficient (starting from the highest coefficient)
//
// We slightly diverge from the algorithm above by updating the result only once
// every 7 horner iterations.
// We do this because variable assignment in solidity's functional-style assembly results in
// a swap followed by a pop.
// 7 is the highest batch we can do due to the 16 slots limit in evm.
result :=
add(0x7e08f9d222cc0764fb5ca69e51ad4cdb7f1b612058568a142bc7a4cdd0e39c4, mulmod(add(0x29f6aa5fc92eab8b8b9871c8449c1f617b808ea9860717f3e5e1678672ec565, mulmod(add(0x5115ade709c058be5dc6f406794062642086e431bab03c9a86d53c79aa83db4, mulmod(add(0x2d6129632b4fc43e4142abf55fe2d1f3e79dfa01c73d8fb56a465dbd07a9682, mulmod(add(0x14f3359ce0d2891d1bc2b6f4d2d6dd71fe22925b8a09f66147db095a9d4983, mulmod(add(0x75a127d817aee244517479bab5c4bfc2a0035d43d673badaf64d8adf94353bd, mulmod(add(0x62b07622f501888a668440d9b856be4b0c3bf12a401fc2bebaeab4a7e1684ad, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x55e928ba557ed7fe0ecde6d1fbb83d112e6b06a087b4013b9c425fa36eb0415, mulmod(add(0x7492aa940f34a027f8fb3700f29cf628c1d05d1675cb7865509f20617a90b2f, mulmod(add(0x2cd9a093ece61e554b2bdde3ec474900e4412775ad25456e5be6e11df7b9fff, mulmod(add(0x707c572424682b685a1ba90dfd7e56f86254862d86e20b5a2d3ca85fe0017ad, mulmod(add(0x68e1d50b4d0570e357eac7bc742ec26dac1edc5b179989c7ae8d31791639103, mulmod(add(0x2b7d501bedc4e7c604b0e55dd2d8166fa39a541efc24d81d8464fabfef3fa37, mulmod(add(0x54c5dff0aed23c07edcd958ee3690e617011b87a5fec541725237d4ebf34382, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xd21afb1901f1b3ad66587a7fb97ee06662edc3bc8c8d32b48625a135ba23a9, mulmod(add(0x7b056cb6f172b25e3555d6b1422ff769fd4c07258fa16b03609f0e374012ed4, mulmod(add(0x60ac57e328ff6938a17d43e6137a55399b95459be60fe980ed8960edaeee10d, mulmod(add(0x2d2d27711772cafff2cad828dd78d8b213e317e8939cf79164ae64dea577d61, mulmod(add(0x133b6505a6afd2e5fada0e53ea51c012e4935ea6d2d02caaa15ffc50a45079b, mulmod(add(0xfd48fb35400aaaf57d130b6143b241db8af174cada72ede8f2fac4ec6688d2, mulmod(add(0x3cdb28a913a41d597915de055aecc59f2b13079d3d8b33ab0a075eeddb1bf8e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x58ccfd44df4e339c65e1423eaad47210f2e16aa6530d3d51f38b70e5eb3a623, mulmod(add(0x47275cd67ff3b7637ed55ced299a6142a821ab466a897f1eecfc8bca557269, mulmod(add(0x709be747b0a69a9523680ff69e6bfea4637bd570ce5c45256b39ff695557da6, mulmod(add(0x6aebd7a9279eba43cb1c0b14bb723dde464a86cac92518ca16ae27a8684d9cf, mulmod(add(0x491c2243a95c44528b86167a4418ff9d93a04bde8dd7a5d2b19ea579d295312, mulmod(add(0x7c1667b8d44d288c4f5150d01c5206d4d5868497630745b6916466c8a5b1228, mulmod(add(0x7784c2e140072fd26e95911df38f9a337107750a72b9ce05a21a0f781b92dba, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xe4d1f1f1f9b379bea473f76bc8f3c4d530335e2d6bd782b42324872767b628, mulmod(add(0x66c5222dc133e37dfa0566c49d107852d978eb7454489d3b2ada8de022125d8, mulmod(add(0x62ad4d764ed0072a7649425270e2b210421c77d3ce98e2587ea5440a591ecc0, mulmod(add(0x8509234000e130c8828328ae4997d5116117716cca9490e6e63f30b7df699, mulmod(add(0x4dd38543d129d0a71b1836c6e2eae47fde5d572e32ee9a5791f7ee823eab4db, mulmod(add(0x660bd8049bd301d093aab9ae530bedc37467d4ff0a12c89d689d61ef9b9546a, mulmod(add(0x28218a1bc7586b71ec1989082b8f7ab0efba14569c6f6e5d7aeee1964ab6d70, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x31eb3b57e6844e3efc1e3975ea393476d8aace5f43ca62b09314c90b8ae9688, mulmod(add(0x539cd2c1a28df263709cf0eadef73a600f563ab3d82c27692b1424814cc3e15, mulmod(add(0x45970c86c25bc9a68f2e2a34969faa2134c95b19230fcfe7436c98f537539eb, mulmod(add(0x2dd27ce7910e44ee00ec3335bd79429846a70d92d482adf81b36a9ff1aaa30a, mulmod(add(0x166b26359c51d067955874f5612eb70806d7b8d5de4d8e0a75e0d57b39b1846, mulmod(add(0x59d753a23735a336c50466f5ccaab3671230fbdaf55101530e5f562a5efcaf5, mulmod(add(0x6ac2f92bc4c04fd50ebd3e336b53b866e790ace39838aa96a4b791011455b29, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x75971517855ffbc9657dab30657ed1e3797307bbec1ffe136cb0d8a64ed6eea, mulmod(add(0x5b02adb78afd4e219642a1fc38b2ef9f63926841ccfda072ac17326d3d50f3c, mulmod(add(0x3132d42e4a928c08a972e17b2c3b500dbcadbe6190b2e7f5b58300a0c8a38c6, mulmod(add(0x559548517b1025ad61020be3e252b6ddbf1d5d53043231f8850c0da52b8268a, mulmod(add(0x4538fc863186b4babe3b424b4111251bb1e20ba5516be54160cd560ec0d5a3, mulmod(add(0x2d8ae7b28c8c3acc8bef3d4c2a9f5ef1323748de693a9a1ad3ff8601116b165, mulmod(add(0x47359c8dd2b86e4f634a9a50950abde25942877bc5db93d62bf43d2886692e4, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x628226c46fe0bfa8aa36074ed0785cb16461ee2945ecee9deaa6399bba2742c, mulmod(add(0x78c7b0512cae47833eb6bf01c1075aafca19eef9b32e37f4f9a9eff315637c7, mulmod(add(0x218da336adf8608530fdf8320c4edc00631d36c8726430732038a369548cf56, mulmod(add(0x7e9e1c3d4bd3231686c235a495f737a9ec3d633331a95d85e17e90f99a08af5, mulmod(add(0x2037a7d08a1c4fa4d5d4f53436a252302840007c09163026637e9cdddc958f0, mulmod(add(0x295fb60eec46a40a33b1a9532427b42e224c0ac6c50e3c1c5d17c2c16651a25, mulmod(add(0x174a4710688db61da7559255caebf641a268b4df53d45de5e8156d36b4b2ab0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x76ea16625d0cf0c04f096ac7d6eacafd00809ef1d1a3cf5e37dc2a13a02d303, mulmod(add(0x21706619a453a544bee0ccaceda9fe69f860c894b36bc9cb7ea4455dd88a9ca, mulmod(add(0x55ee57d4096ccf0260baa2a1a2639978d965a786e4fc917cb2426f8a99591d2, mulmod(add(0x1d5fc46deed0eb9b56cba1d2bf8075227504aaf6ab1330b346cc3cb84a07cc8, mulmod(add(0x4221572cf29651f508bab9eb82545b17cf6f9efd0416b65262e5491ad408e39, mulmod(add(0xdf82eebd6cde9b50958606c6ff83c855c43ce9613fec366c7792cb456ea913, mulmod(add(0x2eb6bd70a00ec26418d347df1a444f7ba0972416103f00c771e0f3d50bd8e5, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x27e3cfc87448bc0392a0d6c1b1aa06626636fc703bbcf3717fbe6f0759c4855, mulmod(add(0x2a45de0b79a4e9c53d47f6126d35b1d050775d5fb17f3c3dc22c7b6476608c0, mulmod(add(0x519de0df91b17442a8f60b512297d69a1b516f70f67d76eb9c287f06e37c55c, mulmod(add(0x2ef7f1dfebad70ef549da1a143c838cea27749807efcb1a0a29cfab16420928, mulmod(add(0x12b9157240a237f319beefb6019bf0de1897b9e2d8e5536e3a21d8f9fd689e7, mulmod(add(0x471bb97187c83c0e7b51ab70022147e8d8ebe25d4081907e7d1bee8d6c6581f, mulmod(add(0x6d0d885e8d2530c7a324f7b2ef47db35aa8162289a4420a54f13a82b871d850, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7ce49a9b8d374e1174ae6ccea7cae8d743404552253f7ec854317722a5efffe, mulmod(add(0x2c11fa8c0ba68518942f1c686dafd32aa26545886d28cdedae00071360df674, mulmod(add(0x6a39a27be962632e0bfb245f65a4d70912d1572e39003d63def5f45bbcc8f7, mulmod(add(0x13eb9f5362c087af5ee758bf0b589c0e34af337b3c06c788573534e96de30b7, mulmod(add(0x25dd21ff92e6f1075df6b5ddb2b774ff963b1b84a985261b1e94ca9eedaa49d, mulmod(add(0x3139ae970d95891aa70cbbf6f172223e07eb521a5149b7e0c9202793f6dbdb, mulmod(add(0x77a45066995089dbd4072d6817397ce0c7e92b53d19338e9bd7549e954bd961, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x154a5ad294d41caedd8d927eac226dea1e2b78f6ed0a6901a00e45ae0ad78f6, mulmod(add(0x1cc7ec07c4e1e6626b5263044071687d0ad34ad4d08996a213380e9b728585b, mulmod(add(0x648c35904fdb8bbf9c0bc9288319c248e17974fbb6616a70acdac004878bb9, mulmod(add(0x76914b565dab13e76053b7a74c24c005b0930011e48ab26db44b6b49a1e7ae5, mulmod(add(0x2c29d0056cfe7325567a9f2d09d917b37a45aa3cefe20b78c4bda2942af59bd, mulmod(add(0x6123efb57144c151864b4f717a44cecc667fb2ebc47bf24bda4f7d0ef8f550f, mulmod(add(0x6bf518769635f9fa39c1258844d4f62e5fc00b70792944da0a939990492313b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x61b210c04a0899fe2a3dc53348507d6f53d4cd3831644e4630eb40564ee5b47, mulmod(add(0x6dbd918c7623bb07b05ca515146ddd7193373250e0836062fd1c430e2b7894a, mulmod(add(0xe2acacfba8f832e4e3cffb6ecf4675df678403610fe91363172229444ac0c0, mulmod(add(0x79c11c262fc2efc9aceafe4a5886713151352e60c4db45826e0e343cc5919a9, mulmod(add(0x5e48cfc304417473eb4e587942a76921fb007d8b11ce648d36828e8cbb5d595, mulmod(add(0x2b2b08bfc4c3d5941538b2eda43b3cd009656cf83b6b23be56b3041df3dbb0b, mulmod(add(0xbd5fd7dcc1ce2bcd7f7415a22115f0c846d16ac7458e6c531e7e44dc664962, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1f3e3e61713ab64544b28dfcaf4da25b64e625048ca55cc783dff614f5796d0, mulmod(add(0x2b6a2e9d453e19e3d766f24cb7c6753f84adca0f75f7a871092688bb5ba0d37, mulmod(add(0x43aeb91e6f453d372353d9814a85c21617e6c934c694a0b06100e1e9aec4087, mulmod(add(0x10382fdec78a18047041629179e18ec7dd067bed125bf5fe83f13d637a8ff67, mulmod(add(0x567205f3e5ec69ce7962918c41ed0309c3ddfd85fc92702ce1c207b282f17c2, mulmod(add(0x3c99839cb11fecd878ab9efd1d2ed2a718f6e0df4caac1a070de06ddf1a6091, mulmod(add(0x1e3816f2a6a4900b65d140d144225a8a81cb3ea22f56de3cbcfe3944fc0e898, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x787a6c80d5a23f91cb91d2508633cce6125da76e797ed460256933a4e6a24b7, mulmod(add(0x3085800be446839854dfb7bd9ea67ff139267fb5268faaf153db26b00368630, mulmod(add(0x4e28bfd662fc5e09399fc49a49a622a7e845631244b9472df8c91c4a703321a, mulmod(add(0x8981cc99962f20f8814162568d9d7edb7fcc637fc6907a98b1d1eece9811c6, mulmod(add(0x78e4cf312ec50466bfea965b655e9514d9d69bf0bae566fc88187fe730f70, mulmod(add(0xf9762bf5620ec90d711f12cbe600f29906fcdcdea4f17cf51ffad2e07887e2, mulmod(add(0x364cf25e248a3f2fc2106025945389328c0ef37848a59ff2afdc685c0854822, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x41052d90f803f015bee5bd1a5f6e2f78f30439ecbe39861cdaebaa8f7c56371, mulmod(add(0x1e836012f5509ea2f3dfdd474e9e4a96f6924e6619924ee4c6870a5294e26a9, mulmod(add(0x43fa3aa05db6331941265719fc1ee057d9f3dc81704f81c2ce7faece0fe86c6, mulmod(add(0x5ffa0d51bff335ad53cfe99165aa64f5ac1b01c360bd0101856537fb03da5ed, mulmod(add(0x4f62f4d968964e4908d16fb9412f8d10eb82e14e83f3e094a02470f27eae006, mulmod(add(0x58afefb8e3180356e33794e20db869aba4bd4e5dfc795f8089d6f123025179b, mulmod(add(0x5ad768a2e70b4018e505bb5f6f44d249d9f5ba5f126106cde9be7726cf5c0a3, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7e31ce22d2a3d776ad90e008ce82c594dab9ff2c42708f4f0676000cd86891a, mulmod(add(0x64fecb621f4dc18fa1b66152f28bdd15b7b12d495c496e77016bf3b979e4b1b, mulmod(add(0x17a1bf17777a3b56a76df412810d05c9e222027aca604791694d3b020ea40cc, mulmod(add(0x5b553a6606a3f01d862af22a3309a6df0aadec753fd1e0321b0eb08504c1f12, mulmod(add(0x6620ec871e8a2c03933d0621b13e7f357b7349ea16bb549e7e15e2652692252, mulmod(add(0x4b7236fb7f8b72b2d369effbee5b4bebe7d2205ed72f9831b41c711680cbbf2, mulmod(add(0x16f6ec82023f48ea80196121afab584b9bce7f01e9515d0a3b489d68df3e2a9, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x14714592154025f15704e279d2db4c70f545137269ccbd82c11fba275bacc85, mulmod(add(0x22cf3cd9fc0103158f7de369046ac0cff77c44c3f9c6ca942616fe7d59d6231, mulmod(add(0x51443fc9bbe11d787df4afc59f4366629cfb3a14c80cda1caa1ce6107fd063f, mulmod(add(0xf8bd8807280892ca46c092b74f845d90f3a6b61b197a0594fa30686ca41a5f, mulmod(add(0x4509575b94136d744c8679c3028b0db514688db5338c4bcc9f50ccd7d15c95f, mulmod(add(0x35fea15e2101714f172da73da6ddc2077ebd42ada067e7879bba8c2ee1d9db1, mulmod(add(0x43530eaa364a9df353dcfc154bae168e0fa9b51a3362c6cb351d47bb7f6b829, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x203ddf8cbfae2898d2d2f183cd0efd1c3f7db1b84b8e96e38f2b87b4bdad1bb, mulmod(add(0x4ce9244cd3966ce1a6fd7f8b85fb1c8751e35aa53032f8063535665ac3a69f6, mulmod(add(0x20d846afc1a11dae8646d542770f294b9c9f21f1196fba567f2f74d058ebc25, mulmod(add(0x2cf1eefdbf254a549ddf4069288ea075d9aae074aac7853005b57c37c2039e5, mulmod(add(0x64ff5a81d9e22197bb59e8cb340a0f44e22e226fed168f8b125d850bd727b7b, mulmod(add(0x2d9f309e84716b322c26aa86a3fe3cb6ff230e0968dfc58b869268c751e510d, mulmod(add(0x1d44a3f67a1142e7922f4329f775fec5f8bd2d32ef8ab41a00821e76fbaa89f, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xa6117e45c1c561307d63895569d34fd7e3f2b2ea088dec37dc3a5527deffd4, mulmod(add(0x41d785e118be2d27a159ed5216de66a84873e1f62088726d9607c6443a14090, mulmod(add(0x5486125e0ed23fdc42a4f8c96cb08d934b6f3b429c4af5f8396618e978e9811, mulmod(add(0x66af1f51f840c438b502c2a5ab689f9b38c2c96df36988710951bf185cb8501, mulmod(add(0x619cb05e71db22ca1ef274bd0a7cdaf4fb79b3015b96f44814b490f048d2af0, mulmod(add(0x8554877281326c1c7e1f3a2f5e81341554ecea862c2677fa67ab2f88b3b03f, mulmod(add(0x37b40695420e59161b338e413a72daa6909f0e4f6f85426f8eeb6bd0dc3a1b5, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4e1cdd107e3116b4ff22720938a201eed2ea0b499bfde301562f5e39a42b066, mulmod(add(0x77bdb42e999e93273fa3cbb7ae7160522231680eccc4d38c1b8a83d2a0420a7, mulmod(add(0x4f4cd7f9fd5b694cc5ea6154d0738cdbac3978ce74a7314bcafea3dbc1da61d, mulmod(add(0x5cc1da57cf1059231e195a26b1323599c95f98e4b302d6e6f4bd41180b56d35, mulmod(add(0x3678ebeaffc3e64d76141f41be973ff36e8398a6aa0385eddaa0c4183e3646, mulmod(add(0x3daea06a4a96480c4f7fff1082d95836964b63c14281ef942fa9a9890d8754c, mulmod(add(0x3bfe2f1e8df44829fa27a78c46c223c7e64bda85be60d8a3a5d0e7d36c20e29, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x11a9029a5c07557ec347592ba7181acafbaf0f0c5c9e81d7e995a4de57fe566, mulmod(add(0x7ea13011e0dce5c917be4cd36c8931f5969852109a16d7c5142e8fb3c8b7650, mulmod(add(0x2bc791bd7e68342116218ed9bb657b8b54e550022e39af11ce55b29ae49218b, mulmod(add(0x4d0db05514a8c0f152a8664579c004fb738cd3790214984bc3f21f31d494361, mulmod(add(0x1ec8c3c39ec4705944ffa8b3b9b61f73c9ad759cb79a107dd93a125685f5119, mulmod(add(0x23d7ed01587af3b9aefeae8a627c6401d36245cafa9367631036d2bd7c47e26, mulmod(add(0x513bd3eda9403f4167249972ce4947f3ac9e9da03a7b9ef557a65645b9616be, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xb04ac19a9f1483b8ee3b763be73814c9621fb3d23e6d874d9093d999d3d4eb, mulmod(add(0x2b7f9df93ba787a9a5a7a0a3b5daba02e2ce65df16ada37575735697eda6c1d, mulmod(add(0x3ab952be650de0c679ddc0a35bac2907a6e58303059d4edb914e74c67d05226, mulmod(add(0x2f7d26f183c54146bd83514f5459bfd95ac635649d74225c2168a8e7baec082, mulmod(add(0x7a42c4e98f014e50dba6b25fc32401b7695fadb7bf271fe0a763712ee545c2, mulmod(add(0x491899cb7600abb42ac8cd91f2c775ec410469573f57c1030ed1582327eedb8, mulmod(add(0x359506efbff0e2b81d91cd6a5f808a6c65255e1bf06cc03dbaba94758b3acfd, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x6ae2e00f7827692b0d20f483d3c71594f61d50846b52abfee39f6697513c0d0, mulmod(add(0x625a1fce22a9fb7717107b137a0f5ea4ca059008f5cc6fdfb5cb5bb1734bd17, mulmod(add(0x309bca858a0f9fc5a468a57981c9c6b7c79636b1f31284938d1c6a21f006a33, mulmod(add(0x4db70c63a1dac4e5ddde15e3626d009683aa8ea14face2c3fdb6ec97c8a86a, mulmod(add(0xb489643a1aa2c181b4739d45582e2576a6f9bd51c81d300ebdc3a58b79bb2, mulmod(add(0x1522043741ba933948d7298114b71322258a3d4e7cf2496590c35683dbe2a7c, mulmod(add(0x4f4df07e55d3ebf0ed955bd9f7c34de001f09a92c1ead17b0c1a485d48a4329, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5c01501e6a113ccca7cc9c723b1fad6ba60ec5b0a85b7d09c72120d3f733bd5, mulmod(add(0x411556b9c89186a2f9f79e55d045295790b28af97fab64e77777e3828532be5, mulmod(add(0x67801dffe217a1a64e0b12f405157af52025266fcc391fddaebf3b6c7ab79a9, mulmod(add(0x588747248358bf8bdbd990996cb43468c89909cad0f8230cc939538b9b331df, mulmod(add(0x55351e9d60f58241736330de978242e4e40c4209a7879d7ae3823c148abd82a, mulmod(add(0x66a63b8ed2255586855fb30333ce0e2ff4eb2b4cd5d2125d8d20cd3fcfc1d04, mulmod(add(0x4b5acbaa0f7e360885677439654649256829cdd6d4a6c7ffa904a0683fb5fe7, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1c867fa9ae031469be012c4f201ed3ad56573a22891351012ad1f7d300361f0, mulmod(add(0x6caac68bec6ce4eff4f74c1f33dbc027165cc02cec8f69e9470ff99c0b132c3, mulmod(add(0x4e0a6e0c26f85c74373782bd2924f3bc0f6b4a2914c4f7f8850a79eab580566, mulmod(add(0x4f6e24500755d20ec5f28480a41a0cf23baa1aa24202382e9f4ec8ec6d7596, mulmod(add(0x7d9c679179dfab605ca04e1993b37ddff490c440665005698a47c442a1cc10c, mulmod(add(0x3013a9c6094ab0086b1397621f93ac07bf45574ea26b09d3e4587afffe995ca, mulmod(add(0x5b0d578cb7aa59ba02b0bb894848b745440c0cf562c2e635312c9bfc305e169, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x65c04013accf25a2cd1d9eb98689d71694ffb20dced009df5b9af167602b4c2, mulmod(add(0x7352e8793ed3f6283e492544b2944d6fea715980d8884f6821574d36868b0c7, mulmod(add(0x9be8b219ca1684dfbef720a3e9f034b319e2d233aed85063924fc60aedf20e, mulmod(add(0x65c14f7de75359a40c5f244f78b2920b61087fdbbf59aa507644d94f5bd210, mulmod(add(0x6a4efc048a81614dede6c4f6181253e84f20d4a4f95f973147ee3fcd72077fa, mulmod(add(0x4a35c4582c91999a39b553248bf2a39ae5825204085a9e98bd6ddab3bfcc0a4, mulmod(add(0x1761abb092f6c4e3eda770480fb4ab095e786bc3f1b1f960bc4c95232308b3a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x400330fb079fb4cc8671ea9a996de8f5442f20b9b9a3bc9df8b81e01506c5ad, mulmod(add(0x2512f776d1b3d212be7c2adce1cfa083d1b2b9af1c6f3cc424b266bfa19aa06, mulmod(add(0x6f6131c193cd7b3fdb4d0848df70474ba9e80529097311cd7c13e322205a1c0, mulmod(add(0x711628cee8d673863e18f058cf82551ca8351486b9b210873b4e18447e11408, mulmod(add(0xd9da926adbb5ffa493c54223f97fa1b0d141129d8736bc4f5768426c7e82a2, mulmod(add(0x162e6e8431b7280f8401ca08922c5452c7237132efe3a481a71b5c97183e9d0, mulmod(add(0x679bf3101f8b2112eefab47d7372f0297507511c7cceb4478f2baf0541740f5, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x152c16cce8c1c782287b8908a790014fe3c51c57cefaef63e2c8dae5a7a5daa, mulmod(add(0x74a39339d1d708a9ea407f03d8b0e5ab103c3251596258b78be1bd97ad06915, mulmod(add(0x37f1342e071f8a087c1405692443305d28d4c11b84d92bd7dedc563fc3ad329, mulmod(add(0xfe9d827d7e6387c7228d92f78574add4ceddddac1fbe71dec1258220c08402, mulmod(add(0x4adf53e64235d5327822ee3e584674af053e496c5d92a6c8c43e1e8e7d327fb, mulmod(add(0x59786091e2d824242c7aa5dde34ffbac99f6a9a1aa5ecc8a395aa13e8aa55af, mulmod(add(0x40cfb729788e16fa80b7d937f0088157d18ff2cf7c79b748d0e150c896d348f, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4f847058896f8e2727ef3b4577e62d5f6a729696b8705fe217b97c73fd1afee, mulmod(add(0x614509129cebd380f416c4c9c7127ee7b53d878860905f047ad722a82147236, mulmod(add(0x6235547369b594514d2fa1ca9b06fd25f9d2764fe8b099c7d9671f542a01d46, mulmod(add(0x5609324fa7ef5213591c8d36c59dd42df8f5f26f84468bb84f843707a5c9c48, mulmod(add(0x44041800e20fa7a15dd9274ea8283b09c30a0d900d9c165217004e669b39d99, mulmod(add(0x3b4b0f9b88e16446a2de79c1d8c34865d5d6e581f08bbbc652ce67d8ac1d952, mulmod(add(0x5b32dadeb15d554f39f227de4ad20600eea4b763fa4c90ffa1a41812ae43479, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x75f781602ada44803c0ca4bc8c1bd5064700762d18c309a2b9059dcd8c3dcca, mulmod(add(0x1e149d42cd477212ab7f01fe40f76858f09ce2bdfc397df635ed8a453714e7e, mulmod(add(0x528d041bf152aa3a0205430412a196619b68c81d7a706fea0fc090e0cc6a105, mulmod(add(0x45fb29b3ac673e9f525332c8bad73d76521985406fc09398078b30339c857b5, mulmod(add(0x1fb19890707fa2e617de7dcea9ad35ce9960009f1e38aa2629c66fa5b8d5d19, mulmod(add(0x5897638208b8e9509d1128c29af87cf30c57942d47016819435b373c0a309d7, mulmod(add(0xfee20b19c4437f06eeffccb05b88c4e236d18f8e3518ba124ab4eec844c496, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4cbae4979c7a1313c2d0f68b21f5734ec83f9e1a88c78b3976a6ef84a1b6dbd, mulmod(add(0x76594f29261e2aa9cf4a90b58b0f79c2aaa99d63c4ff64b4806cb8cfb0df316, mulmod(add(0x43e371660fff35e52cd5dc08c9c347d8f7c64a116375d0e6e3ad3512d85a99a, mulmod(add(0x52a36a173c7ebc96cfc55bda4bbc73bc349657d39ebe096725e9cc4bff01def, mulmod(add(0x2849ac77a2f5398eef51aeb8312dcef8b347b690728d4eb835bf4670301e6e7, mulmod(add(0x304103a8d35f43cf87d50682e86e473fffd71d13e0c783e596a59a62b06402d, mulmod(add(0x1571843ced13a8d342b63c63abc4b83d357eb286af04380edd1eaefcef3f1f8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x719df2a50d9c3f2eb3f0336665f2980e432191e21fc49f488854b8352fd94fe, mulmod(add(0x19412ccd078bf5665579cbd16035a251e08f40722eca4452eedb31732488468, mulmod(add(0xb3dd17f46d6b12bf4e5db184d6962c156bef94f9f73861e34d88503fbc517a, mulmod(add(0x66e2651e6f5758c334d1c1451d563b2df07b424b5d0125c739ada959479890e, mulmod(add(0x2ef5951aae064a7357b1e4ed49f05f17f778f2e8735f8d17b5cfb82faf3b848, mulmod(add(0x64f8c462b308a1337bca235add2482fdc3607507b2c9c0f91b9187f5676303, mulmod(add(0x76702a08064b5768ae2979aca07322782191172276f1bcfbc14cbaa3e758dc, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2b51d7f94ec71f3a8e3e20d766a4a7f13d08d758a686ff86dbda48026c7ec3d, mulmod(add(0x6232d26f420f9b4f119e64762927b5e8a21192575b200081b0545ad4e9a2c25, mulmod(add(0x298215f335fb63a11d31958d950d95c909bb94e144c113cc4ecc08488469097, mulmod(add(0xd49f196e60ebea0eb13d85f05cffedff32477e83129bad30bd9dd555755429, mulmod(add(0x74e503d57e49daf6939077c0b4a4d68e66bc2425ce53b01b48f146295476401, mulmod(add(0xdef6a0b2b71d97a59c674c052fe23f7d000a334e180b0793b6974fe29a64c3, mulmod(add(0x459f095ba3b70f76e493c6afe2d4b6eebd21343f74bfe3390868612fc250fdc, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x65f4a97d2b1c90582859966540e839ac2d62ad2ea960aa2af36776b2d07ce34, mulmod(add(0x184ee38f80fa532983fa248c14c0220c2a5691836e899a5c9b83c975b03608f, mulmod(add(0x13ed29a84c4875ac188521bc40e9258e03d83c9ceb8716c6fbeed065a5df73b, mulmod(add(0x6a81925732161d4e5dc61ed6a10726027fa66d892aabbf46a477f4455072c02, mulmod(add(0x1b16d94e84ffd3ad61286f5a79d5a6f7b5b5dd6442aea9013ad21467bf1281d, mulmod(add(0x70c0f7da90cd889d8df06f9774de8a9a20c88e86753506c7afd0e1f6ef15e76, mulmod(add(0x45fb08bc21969d5ca9b1ec473cc92a4ad911de8b0607ddc12b9ee98c286d37f, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3c835256339330b1c94cad78cfefda36a949b9c8553d918f3d8547cd1805ac5, mulmod(add(0x325f10662fc8bd38e591b0e8caa47b3fff46703656b2c5863d39c150d298fc8, mulmod(add(0x77434256511acfd027b41e03a571a9f56b0442dc675c139a2e1476fe716102c, mulmod(add(0x73eba0e9e52c3a93ab6dce26d5858b2d699d8401b2c43253616b5701aa803c5, mulmod(add(0x61c61341c83517cb7d112a76864271492473e04130ce4ce23331f7300bd8c89, mulmod(add(0x96935be4e41797417259166181bb646a619ef95cc8978ffeca81d141d062f7, mulmod(add(0xe00ac968fe5a147fef45fbd626c540a194ec3dfb2c1cca7938e037349d4f34, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7caaf4f7b073af26c036d8bab5c74fc3f752f9ecc01041787e9ddf773596189, mulmod(add(0x6321e76192ba31cc63bf7c526c8ebbf4df5b705f01e4151068ee3dd658aa674, mulmod(add(0x72bafd4641e6928ca65cb48e8001ee077944201f70d5bed524c69b709410d3e, mulmod(add(0x60c93d3dac2628ad796e1dc80bc0796d054c991ea23094d699bffb43a630add, mulmod(add(0x78562cbfb984ebea085472a1b004dbf86e7d99f4809a5020969246a84a9d165, mulmod(add(0x17d8ab17e403b1925b40206c11f8a6a29ed08217e1ef303906ecb354fdda1f3, mulmod(add(0x7340540d0c9f9dd2c1142f03f408ab977afc7371934c62259fdd29f0652f8d0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2f2f5447e274a20d9d60615f83a18b2a4db300d5e199d7c8c6c6cfb754e8cbf, mulmod(add(0x687aac173963fe1e01f9e0d50eba0e95e1e8783eb21c0f6c1f45cd42408198d, mulmod(add(0x1c933d3449f6241d0f9d547db9e708fc2ee3e0598be5f87b675fb6736a15c39, mulmod(add(0x7ce96f5a3261a977f04ff70ef416a3d5c165100d19f551a6ac514e4d00fb18e, mulmod(add(0x35c99bed31baaf7833ca759a9bea792965a87b42171259ac51b00d872d581fb, mulmod(add(0x5b6477413bac2f0d370c0cdcdec4cea10fd322fbcd7b202d4ccbeb0581fd34f, mulmod(add(0x66ada08fe725f364ca32c1055e1ab1216967856d6cd8762dd4ea915c2ed40e9, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4fefb86cfccbbea031f15d85033f10f92f2b6b689153e305bfa8821935979c3, mulmod(add(0x3cbf28927ecbda443555c9d51f40c294fb6688a17812cb0c85fb6501cdc0709, mulmod(add(0x33d4fbf9dae7a87cc13db3c95ed3976b50113f072e56a13e675e4af241bb864, mulmod(add(0x2fcabf82bfd2529eac169a520cbdb2a0f8c205c5a9b1f1ac69bd3a44b25faa9, mulmod(add(0x5455d2de2d7570fbeeb431a9a21187ecc049874b64a227bb543aab4af16e27b, mulmod(add(0x282ad11848887c771898b5a32ac6ca14cc2510830454aa8e194975e308fe042, mulmod(add(0x91cd6c3b8ddd8954a44e8a9cf6f7f183af8e6226849f05e6e6ebda2409e042, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x160d7d587f3a17673bf04189e0062c7bab764fb54ebd0f042fec72f953a91da, mulmod(add(0x25446fd382a1b0f5350b91290b2dc35a6dabaf215d53cbb32d1732fc6ebfffb, mulmod(add(0x123f50f65a68168d6b43c464270479801376ff6979b94f60252a47d9d7d34d2, mulmod(add(0x11243de8b4214dc3220693acfaa6b626cfc3b8c812140779af9b72dfb1b92f1, mulmod(add(0x45a5b88744e83d901f33da0d0de869381e7a125a6d8bd104cf72ded013ea4c6, mulmod(add(0x6c74e3b74559e12949b8c3b55369b2d275b2920b4442c536d63f91debd61499, mulmod(add(0x63f4ad31c4d59ee741b1b0ac99e022959df079b5b033ec7a1ecd3b4797f94d9, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3d368784067d457e43cb63b3f526e721fab153949b090a99a128c5744fab4a2, mulmod(add(0x6da4d6fb1e6b2f1b42910a9dcc4702912002d7d36ac7100e19c7f298c7948a8, mulmod(add(0x31563499de399383464854a8679e0b073513c5bc46cdcc2a2107f00677e6356, mulmod(add(0x6c2a98464d6eb4038d55b57632bb283ab091eac255fd6797df41612cfe3ea1b, mulmod(add(0x2848af5bb20ab624881dc9244ea18b1d6939e14270714253a896e57cb0f63ea, mulmod(add(0x1925470cee5111eb991ccc8b0412be603c0b8df342d7b186a3aaeddae103bf3, mulmod(add(0x1e0fcefcc1d1c5a69e81c4fdfe7de04d95b53c162a3b64b5956df8e59e1b93b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1fefe6ebd886640df863e5f5c25e9b42fbc10adfa7ef07d1fda0eabafa60a6e, mulmod(add(0x3129daa367a01a45fe3f0ccde215371f59c5643bfad33f4269a6478c8c8b7f8, mulmod(add(0x41d1ca4f756c80f197ba1635314a3dc756f9d8d9406af16538643d3e1021bd7, mulmod(add(0x6ebb7c4ee2d4212e6d7cea8c16f97c935f3bbbc2f400c9a738f1ebd37eec6ee, mulmod(add(0x1118c09adef545b07e209d88b0a645673a103c9e71e8f671e74c84abf1a2a2d, mulmod(add(0x179f2a40de3db251b95a60431e7cfe2dfa48dc8654bbf81add938e9f2f6725c, mulmod(add(0x266b63657dbde655f034c014a8fb73b77138b52eb0e17eacbf402bb90305f10, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x41354bad5cbef57b0e7eacebef8f0176f3b70992ea5a418f502242acbc4a1ff, mulmod(add(0x690c8328ca161c48f3f8f37570e42095d1a0d9e101b3ec0ddc91426fc22facb, mulmod(add(0x7393709fd08807a84ca44526a2b8ec97bce5aad1adf00560d04110de6d9eda8, mulmod(add(0x43e46c5f1cf3b5cac9722eeee991cbcf53af25a4a355a91ea9b8a4d4754d908, mulmod(add(0x6508b5fcc13191197f91407d5b1b21d321b7f311e55ede9ab8a6975308dcee, mulmod(add(0x24eb6fb4dbac687e35d4168b970db6e7dc76c4c886dce0d4bad2e6544b8e6c6, mulmod(add(0x37e79bd72d714d3de7ed2b1ba79e345f75646bf67efd8ea3050ddb357802a3c, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5f4fd7854cf7b89a3983da1a39839d85c7331c3353b0a8cd218f7f4e1f780c, mulmod(add(0x378113f110b2404e7d185e920249519ded728cb1027fa8cc2843a588886a7ed, mulmod(add(0x64028a3945aa2866db68b304dd0d83d75ed0ba5c2f9d0b47e80d11d8da6526d, mulmod(add(0x5526001b8a8c2c6209e40b5d380836bcf63db4ef85c25fd5b72d749b0bd36de, mulmod(add(0x33e7ba5f7e56065e3f8b091578e8e7a7b118116de47237fa5a97e44e97b7f69, mulmod(add(0x33cfe02e240929353f193c6d3387f1117d04f116889f38d9a196abdf986e48a, mulmod(add(0x3475f32b5bea9dbd19ec199ef34e531b696cac0461e644ffb41a5e99d0735fb, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4dc27c76881bb820eb74814d1b69825e9048b1a3b064e603cca4bd4814b2243, mulmod(add(0x5761ff2e0a250691a66dc36d372afbd6a8016726efe0c418d7899d60d26bde6, mulmod(add(0x62dae59d425684ef78c1829e0454cd5e76f5d322ea8cb5ae5e911f545beeee1, mulmod(add(0xe3f2bdc2de2b623c56390eb0044adb980766ae1a58d775e003c39724d1d6f7, mulmod(add(0x684a30c1084e8edf34a77bf8848fd2098459f5461bdf3352faf9c8801435b6, mulmod(add(0x1e4bf5029043367487394808d7ee7df5ad1ad1da2c4710a1b2444ffde106f2a, mulmod(add(0x6467afeee167ea95feb4a85c48fabb2c7067de57acd5098692855189e21c57e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3348152349370ec1c4d753735ef255b50e54aa9a432f48a121c39b8887827e0, mulmod(add(0x66d91bcc591c880303ee4695475e8a8e402926f0c01ade8880c7b03c76998ee, mulmod(add(0x43394095e27ddb7825c0671833a6ac9784f31626914c902c225f05ce42bbd9f, mulmod(add(0x5a347e7937c7a178952905f499babbeda500a820ccfdf7f3a99589687a623e7, mulmod(add(0x4d6c233f7bf3ade219a8e3a89e12d05beb7faccbfa811ebd930c391523f7b4, mulmod(add(0x23cf69cfd7730dd096fd485b2d8bdfcd89ca6004689bcbcacbeff288f18ff9b, mulmod(add(0x5a15d718a45959d16dd6e0b98badbb086e2a9741ac04086f078bc6951506e05, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x72fb3298da88c470a2f93a391063810be01078c8375183b57a024c223f2f428, mulmod(add(0x2850977abc89355540e8abb804da7805ef88b12f40cbd9158ef330b767901eb, mulmod(add(0x3e35aebb590266ea1fdd8198cf3c23c77731dddd95d488a9d9f9837e3bd0f6f, mulmod(add(0x58281d625ddb432caef06e485bc2b74cc077aea9ba5072198e76542f0c69dd0, mulmod(add(0x37f5f6b25ee428e91e886127b961856d9ebc52740ceb763baa7e71371b84364, mulmod(add(0x45ffc1ad229bf52b2531afadd1c5ba120c57b34def87149880d1e5cb6c5391c, mulmod(add(0xfa17235a82497674de45bfa59e61a329b2d0e63eb18ab9b74aa46783e04c81, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x208f0c2f5a114b2342f51e919e4fe44c2a42cd06382d9edc4ef58939b249bab, mulmod(add(0x414215fbcef7f5af60f320e67a845e4a17b0a0eca39b4e18ba89fbe8a189491, mulmod(add(0x287fed27ab81e5f721d2bd5aab0e69f53e94ce5dccc35c2dcc88e12465fadc2, mulmod(add(0x4a048ce90e3a1eeedd4932ff37760fd8b1dc995aff7107bd66318652efd1032, mulmod(add(0x26601a459facdd83458b56099975d2b7dbbc431d41b53f5dd6ca2901dfaacfe, mulmod(add(0xa7da81afc9f3c93366b6e161b1fc7a497d6c770fb140bf4b64e5fc707cd3d3, mulmod(add(0x53f792c81d26c122898d70ed7fcfd8f02a8f5a9ec8b9868fc4490d3a46b4e8e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2adfa41f72ba3b61b9dfa6f017b19682b0b0f8cd86be3d37374aba3ce990a55, mulmod(add(0x75e9c821cdd2e754759306283aa4af8bdbb0ed31f4e978dc550141fd10da6be, mulmod(add(0x709a47e72cda4fdf428bb9784f02f77c700086755d4bdb5b229d1b80a2ea4e5, mulmod(add(0x5b6b3213744858ad659c4c07c9220380d63c01f680986191c8776eb703661c3, mulmod(add(0x2a60396cf912573be2837653283a23702037f614e33e1c6fe2834eee9a1c7a6, mulmod(add(0x6fa8562db8de26797e9c9905aa769e4881304b4f20cb64d718d271c182f44fc, mulmod(add(0x5726e3dee7bbc5e5b4f3ad65f0fb17699efb5936d50ad380785f2b10fe8953b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x46cbc37eff4616daaa86160d5690f5473e24171441e29705ae564223a351c23, mulmod(add(0x78f890541865c12169233143f47a056a91dbd18222c5d31bfb2db19162c204c, mulmod(add(0x7c84837e6872bea4f0448183cecd6bb24a8574456ab91173b04b9423be8a64b, mulmod(add(0x287ef69d6f69ab853e4f0d24b22e4c15169d12c41706dbeede9fb49c61179c4, mulmod(add(0x3b8cca1c3fb2b26b7e206802d52d2ed1c725b8f95407e3ef295a7dd9ee0d45e, mulmod(add(0x78516acc9d32f4e54f8925865c91f70b210f4ebc7533fc624685b3d5daa7b18, mulmod(add(0x6e313bf82c34d3af1e7fc14d811dde163ca6e57accbe476875e4a967da00b8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x38cb4f77410e9a33306f8a4b92b6f76bf239ba44e0ef45dab0bfcb75dfe4141, mulmod(add(0x7239c3b89513196e3cae91f8df8bd79f08033061ba63c089bd764644907479e, mulmod(add(0x57f7a737e643bd859d8a53e1b621c09be89fcca7b96f8e42333e46426f26a20, mulmod(add(0x2762878a5f6665bee609c26e750cd886e239c31caf1508d5a2a185b58576b77, mulmod(add(0x10699899068f86fa3843b06693288630b9ac4b87be7b3726fdba32b41caac2b, mulmod(add(0x1a2cd41155bbb7ceee94dbd01bd876140b1698f03b2ff8f8de3ba45b4ea14e, mulmod(add(0x309f9698e38823c05e56d073d83ea551bfa80ace08e749aa4c83031a22360c2, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2103ea7ff918748c4325a992c561b551b70fa9d97e48a52b3c157799d213693, mulmod(add(0x1b3104591a23f262051182209c0f73caa30e8631fc4413a5bf97c9d51a70abb, mulmod(add(0x4640cb2cbc73d7c9fd2a1783122cb5ee8c68e7c04b0b647d43a35cd4961e4ca, mulmod(add(0x2d9af4ef0d50851ae1b0cdab3587a71728eaaa4e56e67803c5ff9126e722696, mulmod(add(0x4f6b918e40f8022d2bda8d53214e8fd84743bc2280231d3ae772844bbcd1aac, mulmod(add(0x51ceb130c1908fdcfa6896756241fca8f74ab172d98c76facb7b8b931fa8812, mulmod(add(0x382114ce9d712af864a253d29471a436b83ee4f7b8ae3fe19ec3ab315e18d8a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3dee84f905f6a06940783bc3f322a0fc22a984dd244d00a85ea3a4295558377, mulmod(add(0x9b419422a2083bf174263351640e009b56d6e2278552f9e7ee6a6004d45524, mulmod(add(0x6f2a9f716b1fa27c35675a57273feb79ffce02286bcb1e253a8e126c2cea357, mulmod(add(0x5d72a87fe662c05530c3ec822f925a10c121a44c4adecf24850fa2442cb4abb, mulmod(add(0xe051fab79733dd773d13f5bec04b1c20252df512d937f6b7352e4c4fa49cb, mulmod(add(0x375e99f4993200342e6f6ad713711052d518e5dac24681b3999878bbad627d, mulmod(add(0x69fb58adef701279dddeff71e1832aea01ae10a5128a9f744a5a945b5fff200, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3e44a162d501fc521774c75994f4b55eb85878f5e867cacb75c7ff0b7efe941, mulmod(add(0x64035ce25716c9c7675ecce40d3cfb65ce3121439e10367fe29f2742cc02d85, mulmod(add(0x6d5a755e91ed732dcf8afd32eac3b4875843bb116430a966ef88f17aad54c16, mulmod(add(0x6d8f39b47e79d44503aa87a3fdf101b055f89c663bd7ec377d175280f3f8db9, mulmod(add(0x107c8fc81a96a3c13d1ddf04b8bcce0450610c2ee6c127e0f47ce2ed2fa0613, mulmod(add(0x7d52bb08c1d72a66c3e5c60f6742675ac788ec8b4f2178ff9990a04d22c076e, mulmod(add(0x3dbd68c7c5945f48515d975002a1caf1c491c6743f151df31f95c5870c90fb3, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x77f62cb2f9db71ba7a9913be0a434ca045a26704681af5353b7c7860be6e774, mulmod(add(0x6ba0329f670df105c31eb665f3b6f243ab5de7ed8aa59ce9b0683e6bdfd9019, mulmod(add(0x6a226b1dabca8ff2fbb52f0adcf4267a47e0eed089774157f318b507361a0b8, mulmod(add(0x4ea62ac09b98dcc34b5437f6bdb4fb9a681dac12d1ca7090011c73259dcef4b, mulmod(add(0x338c001d0c722d793cc14219415d61c52de28d33ab8bfe5dd31674784f2b568, mulmod(add(0x8b54ed775cf8f3dd5b54fcdea07e2bcefae323f6212b8f54877a60e1f8026f, mulmod(add(0x1b2441db55dbd9b87c45b1afba238ed28d1f2dfe9725d9a4cae3a45e3d59b63, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4ab0da9c66ca2588350bdb85cc745b4c5e7226cf7c4fb69708cddf6e8145f29, mulmod(add(0x209866f9b8d946508db2df8eb9d30f65ede2c99ec8deb2e5a1b7093e9a62416, mulmod(add(0x79708fbce6bbe1c862e988648dd25347d60c9e0981540dd81ccaf78054a12f8, mulmod(add(0x15296a7d071a85f1358bb157d5e62b18a11e189415c16f594a18be7276ed2c7, mulmod(add(0x4dabf5afe371cde17b9fa6c54c1b38d603f345c58d4f66e06fedd8948b402b0, mulmod(add(0x4279b49402fada9fcb602f909bc138c3547baf384dfef9594e2fa488cfdf8b8, mulmod(add(0x770018fe3435297b82b391a3bd2d09151dd3949545d0ef111cdf9fece9f389c, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x6337d741eb226911e37cc48087126cdd89f00941523cda2fa5e965dc4fa25e4, mulmod(add(0x40e394412097f7c06183ae2997707604273b0a4ec1add0030bd7e115c20ca70, mulmod(add(0x43e49d0d9bfd165776eeab9118ea672c24a055a700e35a04426abe1b236506b, mulmod(add(0x5919f2392a53f9b230145d1b5e6da28165dd1d8cc7d28d3310a805ebee721fd, mulmod(add(0x5889b4a99416f2f954450c60492129c5f7a36f875a56dde5188318e88d6032a, mulmod(add(0x55c9e37b0208bfbbb61e5e0e05c72111421b24b45ea53d3ddfad1cdfd243ff0, mulmod(add(0x54578b117a58f5beb0d511ba42110c4696f4fec165acfbbde208a4705045fc0, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4835c753d4b5059c1b4186516851f562e63e348f8810714cc393be9810a1de8, mulmod(add(0x62cea6c83442875da8b98083d8bb18bce5d3d431a3301afc635600578b33506, mulmod(add(0x3fa0ff20cc486bd0b43f96826c66b070a6f6e3df3359ebd2970661f9c679e2e, mulmod(add(0x3b5f2338d066753b2507a39884bddc2d0c5bef88e4bc3e79288331afe9a6234, mulmod(add(0x333793406d06dad0406a859ea2c203aff33e3cd906d6f04aabb0dffbabbc9c, mulmod(add(0x1d608ffab983d8aa17db9385433abb0025c77e27357285448c4ff6a8438570a, mulmod(add(0x64592b7d9a6a922f5cf5f74c56e167ec000436a6b3caec299bcefea25e5fdd1, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x54600ac31d014f7241c14e5aedefdc72b839cb0e98b84aa13f031316af48648, mulmod(add(0xead9e7eac2f6c388de28561955e6009f9f1ed098f70516f2bda28597c9ee03, mulmod(add(0x59daeadc724e9c227258a56b000c6a613db617da41bbeb694521c86323c93b, mulmod(add(0x6c6dbd58b8657f8588bae8a4d990e6f9b0525af4eabe87512c5f6a655c92028, mulmod(add(0x13c6580dce66b35fd24183e1635fb6008a6deb6cb507bf48d531273d5b4c2e9, mulmod(add(0x1917c10cc63bc9f43116c3688542cd867e1a84ce0d3e58dfb0c11c4b0828748, mulmod(add(0xc230c4af49117fa614b1d4d74ef462211a5d55537ac71564ace080dd4b325, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x51778c6b175ce13e994dc1604dac3b901990cbae0246b2cec2aecbe96dd2006, mulmod(add(0x3f1908469233dcf5c433790cb3574261ed6debca41fb55b912be7cf34adc187, mulmod(add(0x4dbc9ceabbf1c8d5c679cf80d9bfc26ab696135792e83061e98b9c36ae6a4a0, mulmod(add(0x30c7ab8fe6b61574f49c3d76b3173f76816f31beb33097d425a94beab6caaa2, mulmod(add(0x5952b292edb661874ff2d3482fb968149f09982bd7a194d2b502ee3dd32927b, mulmod(add(0x23ae2f35a2da5ff92426d59ce066e29a525ee1207de1c370023975b4403ac6d, mulmod(add(0x5370b38ea84ca67c75ab50a4cb8f23f4017175a98b23df9e1c92f92c279e169, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x39007630deec4a6eaf806518c109f4aff9cbfb8826d86f301e562ec560ff89, mulmod(add(0x3d7587a79c4ae9c24934a10a9c1398c04f3915fb6889b72b361505a85db2b69, mulmod(add(0x6d4bd8c4aa4a530d965180c18062d6bc440e6e70cbf0836d6af11235c7fde2d, mulmod(add(0x1793fa490096ddd67530e29cb3e8e9632d1885815be3f9d96375aa5946f511, mulmod(add(0x5099f832fdec91fd27af0d221e009ed6770227d63bcee6e1802cdd122751260, mulmod(add(0x3cfdc71122fdfc7807b2efe35fb6c7691985d2727401eb8a8132d0e0df3cdd6, mulmod(add(0x6a91b3677713dc15cd110c71cb8e174c8ebd8d7df1a1b4120bb4b6b1683ad5c, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x53bad76d22e1525dcec248b73438d6f444caf75794c26144e26803fe2bc7736, mulmod(add(0x373a1f2fbe36dae9a5f2c2b35febe59b53869e1678c8da23bd9e92c3c2ac0a7, mulmod(add(0x4b5e107dbcd02c0dbef4d3a77d66386a864d31109d0d0392847c8919d926fbe, mulmod(add(0x755d64434e4e4233388c34a90438764c568353cfde4311021b45e0f369b0db3, mulmod(add(0x42cdd4f6ecbfd891fedb9ecb6d320f6adafdb274ee15cc11ef4c0436a4e9afb, mulmod(add(0x7f921548c686f600b302290f692a66e9ececa142f691f9129c7d8bd2a06803f, mulmod(add(0x51e4a728ecd68dc30e4a1b5867a1022af5808edafc3cb12d26d43b495528f18, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3c3ea2cbc8ce544c6c98ad9053cb2c35326f4e502214e5f72c7951474b5a84c, mulmod(add(0xcb3220da969b95193a25d1d4d76d1cd1ec596040a7b31da7f64164809bdc4, mulmod(add(0x929eaf221c110efdaa57970581428d66d5866fb9547aab76e89e8971efc91b, mulmod(add(0x1426a2050d240104b5c07a9cdaf7fce03c2accadb0ce98344ecb4942c434db, mulmod(add(0x5fb8d87e82c3547e32ce316e4439d1aaf3723e4a906c91533ba8dd9631f1661, mulmod(add(0x111d440a13cab69043e1072b61c1736cf3901941b4c57d7602b8effa7e74b3c, mulmod(add(0xaeb135e456ad66bb5bb2b91a4aa429915f6f9951aa15bba78576744a698016, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x57ad5370b26ea1478f3fa0346d2e390e90feda8022c9820813d9ddd0f36e7ba, mulmod(add(0x1489d6012d4c9701b63f3610034fb5bfca185c7b01222907781eb104e031097, mulmod(add(0x1668b919fcdf512b5683880ed048853e00f456adde728427fcde63ac9f59611, mulmod(add(0x65d167bcce20a40b78583e4dcf7e3f44663e0c595e18f48f83ea4230b207047, mulmod(add(0x1e0c96f0b836d1e2df4e4063d56b78f38f2ad16040d61855b0f664c066d130c, mulmod(add(0x2a652d2592f5cc1197a206db79d06e3b74a55b1d4ec03c516a6957e87345cbf, mulmod(add(0x68892b41018bc73b541800d91f0bb2a8cd9fcfee8be13bacbaf7dff7aecdcd4, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x73e8c35fa646fce6bf10c33168dcf3d2e40af17ced70b1929826d0ca4ba2e99, mulmod(add(0x243a084aa8c82348102320b0ad19ede41b6bd7ffb3a7041339a13f34f6b5671, mulmod(add(0x614a280377b9dc732773d969da5ddd8cc125262313eb7b2bd38b7668cdf00b4, mulmod(add(0x2039c72c1c7c134fb300e82b104394f54a5b7ffe6f7f00e7c3e4ca6640841a9, mulmod(add(0x6fb8324456f1dc4b423220d18d40de524a27dc4f35e4c780a042f6edc95f97d, mulmod(add(0xb6bca44a12ba7914e575f83cf8b9b8bcd4780622806901dcb9530ff9a454f8, mulmod(add(0x522f83a59f717f37b235c05338a02630ad83c3ed307838f6e795f9705cbc849, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x575b929bc0caa43939bfae95a6d5cd8d4082be7fe0934be4c08f7fd3cbe89c5, mulmod(add(0x3b74f537f03a28e72bae3bf1810f1a2fde1711eacd6bc64bf55f37b3bd9940b, mulmod(add(0x2d32dd179cf74693057ede607e0054fbc3e4194efd6415156f3ec909c37ead2, mulmod(add(0x25ea89f2d7ad620296fda2be181b5a6be626eade8974facd81e53df842c125b, mulmod(add(0x24a083b7cf164138ea0c468f33317d89c97b69378c906d918123f3ed5a02cf7, mulmod(add(0x1365aaaf8c72d7e9b250bd91ee2c2264362e87679abcf2df2b7a4e1eda1575f, mulmod(add(0x64f6f50e51b19d5a90e6d2c9cfc3486dbf2b37c7f949cc4f8ac4dd988e5bdff, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1b18b73effab8a483156d16e87be4dfce1250333eafc784d76c6ee145978c48, mulmod(add(0x3f22422d66d77bda123b47b7f5bffe5527f95d331346f6a545c66887ad75ab9, mulmod(add(0x653405343098520984b06f707cee84ea765ecc932783cca87058b88d0f2bbe9, mulmod(add(0x547ddf1021a2cbacc8081cbe3a5c89b8ae808942513cd6f6ad166b0306cee66, mulmod(add(0x6475aad2a1631a6103b238548fe8a03934779ecadeaead2bc20a677c0c71c, mulmod(add(0x7a7d5ce80c8498175cdd4408e08cea457517e37dcba08d0a6cd2a4defcce34d, mulmod(add(0x7ab2a5ce120c251b658bfe532880535e93cbf88aa60a1b384017195e6715706, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x422c03b47f25f698d3dfbb02556367c97b7d8e2657af2e45ebc61845aa2c52b, mulmod(add(0x3a2c1769a49e0632c149dc9d3f30306f9d9cc00cdb426d58b2741c804c51af4, mulmod(add(0x43b4be816239e45b4d22123c840717fe3e8f6ce53238fad4ad56e27c85f3e9, mulmod(add(0x405f9011670f0f202814795cdf0251b665e8f39991dfe2282a1dd2acdbaccb1, mulmod(add(0x4c35c95cf7170d2ab6b9b6e3c1be66dba2de170638f27975fb5ec12c36a45d, mulmod(add(0x592d2fbca1f86935e587f6cfdacd0a221237bd378e2d1cbadc3d168c7a1756c, mulmod(add(0x2843bf3d789d84faebdd6ceb0eed3ec0acd959732178b00b4242eb5cff0ef3a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x48876d457eaebe03383add02eb4c0c49a09923757428595a4f3ad6299d69cba, mulmod(add(0x4de104ea20937d5d6cb02c4ab4d7c4d03ab2eb16d1b837ccf0c2a05ea2873b1, mulmod(add(0x4245e03d0378593b2d4230b945a2a147b36ebfdf368f0dd5fc22e3b31ac1186, mulmod(add(0x3c05c93a63aad66725d8d25e62f76199a1e9f5743577777caa05832f4e79acc, mulmod(add(0x6b735de6be3ab4aa1425c328c838ba09dec586718729f1e172554cac036483b, mulmod(add(0x2059b2385d435959cedebbb68ab5c484441832a20d67889ff9974057cdbf874, mulmod(add(0x5a47f80b2d6e8c8e89f08c23e4eee09ae23882290a4dbdc5d0b09e713297124, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x40cbcae9364d8af8b767a72b260793922cf1ba2a03fedfc60d4eab1d5f00042, mulmod(add(0x771fefe011becb392f5c379dc9e902c41be8f1069ae3c5e0bf6016b7b1b3f55, mulmod(add(0x6d9c76938c974418e62166285ade6564712e6a263357e11d70f3e1f2ae531e8, mulmod(add(0x1706af2f962881d86f167571fcbb909b6f1e4fa386fca8d87b674335196f44b, mulmod(add(0x416057baac3a1780d7d25b192188b9b3981bdcab0e2dffb2fd95456a5313201, mulmod(add(0x1da9b14257c5c5cbc1a97aff87690dfa51e82af9a11eaf5cb2538f595ea2105, mulmod(add(0x6d6ed610ff1347a9252bf835af9666acc415b28796d968ab76353cdc1181733, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x754535ea8702292678b57fbde36c97454994bed59e0d0e13cf8a6c3ef7a0324, mulmod(add(0x6581a70ec64b4268a4741b4f7de866050d31b69005c782630f4bdc51a1650b2, mulmod(add(0x4195cb2f46ca4e1ef5d93ab3a5decbdc9e74d0bb81d56abcf59304ecf79863c, mulmod(add(0x3410d8b91297b00cf8d438bea18b9ebd55ae441a2f6bac6623a15e43ad64d4d, mulmod(add(0x4dbe5188f23eedad88bab99323be5ac9bf747525c23d4c0665334dafd1f0c6, mulmod(add(0x77273f7030b86a46aee79ed44f0968feb0ffccfa0964ffff141e693fd0fb6d1, mulmod(add(0x274b54e6342ced28b28c62edbc8a6cdb44d1530e0fba56e4940e55d806f437f, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7fe75f49544ac3cf237a17e58179851f5b3e7420330e5861ec505291d9a0380, mulmod(add(0x3b591c6de6700576abbe4b4544de71cd3266a5dbb70740762d0c16a863bead8, mulmod(add(0x5bdc50def36283e003e9ccf2f1bed188326bec8bed554815f9e49062ed6da4a, mulmod(add(0x5b0a8465067d8f43cac5dbc1145110e1e79e0f32ba1d59d2514405a0a806860, mulmod(add(0x446d7e2595a1940ab7f6dec4c9f78953de9c0f4c67a130b55f1894779e73ac3, mulmod(add(0x297d52739d69b228b057588496920930df6ada28e5e2a431b65502750a5bad7, mulmod(add(0x71034c062fdc1b61e812617b037c5dd1e80d158a92bdae7ccaec162fff4edd3, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x688dbf5c443560c219afd8c54a0b26bdc9284925f2cc0adc889c1de024d6ecd, mulmod(add(0x6c647f1e5e8e93fda4bc0ae5d513cb60558e2b44bf885484161bbfb5e093969, mulmod(add(0x3fdf21da099da6c005b076001c5a95f2fe26aeff47e2cb9e8e52166a22b643e, mulmod(add(0x46ebc0bdf94c2f85023a0c1b29d229ef7a23e173d310b814f72c73904f6a5f9, mulmod(add(0x630cb6b8bcbe79e58025a699d489116a875f287fef6f1677b497b8702c3777d, mulmod(add(0x66bb11e034bb55410211b7cd410cf076db77f008bd93f0dc938f089e853f0ee, mulmod(add(0xe09e3870dab755cabbeac23076891b510207da569b75bf32d3f63c8ce08460, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3c782f4a1a6d94adf1448fd7feef975f47af9c79bbf7e2d74940673704b828a, mulmod(result,
x, PRIME))
}
return result % PRIME;
}
}
| 174,143 | 12,969 |
3b343f42c294dc808d0fbb5276c41676ebbe1b88fd4d58c90691871c7e003749
| 25,788 |
.sol
|
Solidity
| false |
301940069
|
eff-kay/solidity-nicad
|
3a3b3fe876ef57f52247aa371b9841ff2589b7e5
|
data/smart_contracts/TigerCash.sol
| 3,712 | 14,511 |
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: the caller must be 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;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseApproval(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseApproval(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_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 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
}
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 Pausable is Ownable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseApproval(address spender, uint addedValue) public whenNotPaused returns (bool) {
return super.increaseApproval(spender, addedValue);
}
function decreaseApproval(address spender, uint subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseApproval(spender, subtractedValue);
}
}
contract MinterRole is Ownable {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
modifier onlyMinter() {
require(isMinter(msg.sender) || msg.sender == owner, "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyOwner {
_addMinter(account);
}
function removeMinter(address account) public onlyOwner {
_removeMinter(account);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 internal _cap;
bool public isFinishMint;
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(!isFinishMint, "ERC20Capped: minting has been finished");
require(totalSupply().add(value) <= _cap, "ERC20Capped: cap exceeded");
if(totalSupply().add(value) == _cap) {
isFinishMint = true;
}
super._mint(account, value);
}
function finishMint() public onlyOwner {
require(!isFinishMint, "ERC20Capped: minting has been finished");
isFinishMint = true;
}
}
contract ERC20Burnable is ERC20, Ownable {
event Burn(address indexed owner, uint256 amount);
function burn(uint256 _value) public onlyOwner {
require(_value <= _balances[msg.sender], "ERC20Burnable: not enough token balance");
// 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[msg.sender] = _balances[msg.sender].sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
}
}
contract TigerCash is ERC20Detailed, ERC20Pausable, ERC20Capped, ERC20Burnable {
// The total amount of locks at the specified address.
mapping (address => uint256) public totalLockAmount;
// The amount of released addresses of the specified address.
mapping (address => uint256) public releasedAmount;
mapping (address => uint256) public lockedAmount;
mapping (address => allocation[]) public allocations;
struct allocation {
uint256 releaseTime;
uint256 releaseAmount;
}
event LockToken(address indexed beneficiary, uint256[] releaseAmounts, uint256[] releaseTimes);
event ReleaseToken(address indexed user, uint256 releaseAmount, uint256 releaseTime);
constructor(string memory token_name, string memory token_symbol, uint8 token_decimals, uint256 token_cap) public
ERC20Detailed(token_name, token_symbol, token_decimals) {
_cap = token_cap * 10 ** uint256(token_decimals);
}
function lockToken(address _beneficiary, uint256[] memory _releaseTimes, uint256[] memory _releaseAmounts) public onlyOwner returns(bool) {
require(_beneficiary != address(0), "Token: the target address cannot be a zero address");
require(_releaseTimes.length == _releaseAmounts.length, "Token: the array length must be equal");
uint256 _lockedAmount;
for (uint256 i = 0; i < _releaseTimes.length; i++) {
_lockedAmount = _lockedAmount.add(_releaseAmounts[i]);
require(_releaseAmounts[i] > 0, "Token: the amount must be greater than 0");
require(_releaseTimes[i] >= now, "Token: the time must be greater than current time");
//Save the locktoken information
allocations[_beneficiary].push(allocation(_releaseTimes[i], _releaseAmounts[i]));
}
lockedAmount[_beneficiary] = lockedAmount[_beneficiary].add(_lockedAmount);
totalLockAmount[_beneficiary] = totalLockAmount[_beneficiary].add(_lockedAmount);
_balances[owner] = _balances[owner].sub(_lockedAmount); //Remove this part of the locked token from the owner.
_balances[_beneficiary] = _balances[_beneficiary].add(_lockedAmount);
emit Transfer(owner, _beneficiary, _lockedAmount);
emit LockToken(_beneficiary, _releaseAmounts, _releaseTimes);
return true;
}
function transfer(address to, uint256 value) public returns (bool) {
if(releasableAmount(msg.sender) > 0) {
_releaseToken(msg.sender);
}
require(_balances[msg.sender].sub(lockedAmount[msg.sender]) >= value, "Token: not enough token balance");
super.transfer(to, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
if(releasableAmount(from) > 0) {
_releaseToken(from);
}
require(_balances[from].sub(lockedAmount[from]) >= value, "Token: not enough token balance");
super.transferFrom(from, to, value);
return true;
}
function releasableAmount(address addr) public view returns(uint256) {
uint256 num = 0;
for (uint256 i = 0; i < allocations[addr].length; i++) {
if (now >= allocations[addr][i].releaseTime) {
num = num.add(allocations[addr][i].releaseAmount);
}
}
return num.sub(releasedAmount[addr]);
}
function _releaseToken(address _owner) internal returns(bool) {
//Get the amount of release and update the lock-plans data.
uint256 amount = releasableAmount(_owner);
require(amount > 0, "Token: no releasable tokens");
lockedAmount[_owner] = lockedAmount[_owner].sub(amount);
releasedAmount[_owner] = releasedAmount[_owner].add(amount);
if (releasedAmount[_owner] == totalLockAmount[_owner]) {
delete allocations[_owner]; // Clear the address history data.
totalLockAmount[_owner] = 0;
releasedAmount[_owner] = 0;
lockedAmount[_owner] = 0;
}
emit ReleaseToken(_owner, amount, now);
return true;
}
}
| 159,457 | 12,970 |
449f5ba77808000601b628c44307c2bdf71197c76e3a3ebaf8bc1afd1237d863
| 10,753 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x656FC57e7B931B7BC4a2D1A6BbAEC282587F99e8/contract.sol
| 2,626 | 10,346 |
pragma solidity ^0.5.17;
interface IBEP20 {
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 SafeBEP20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IBEP20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 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(IBEP20 token, bytes memory data) private {
require(address(token).isContract(), "SafeBEP20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
contract BEP20 is Context, IBEP20 {
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, "BEP20: 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, "BEP20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint 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, uint 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, uint 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, uint amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract BEP20Detailed is IBEP20 {
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 ThunderFinance {
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);
}
}
| 253,554 | 12,971 |
d2ae962c9198f69ec6726d78a473f1122a9bbc40eb5c2b5d1ba58032203c11a3
| 25,986 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/36/36815f60e6a747f10ff379bd6307200ac3603300_CoinDistribution.sol
| 4,368 | 16,045 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
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 public _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function getUnlockTime() public view returns (uint256) {
return _lockTime;
}
//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 CoinDistribution is Context, Ownable {
using SafeMath for uint256;
using Address for address;
//
uint256 public totalCoinAmount;
//,->
mapping(address => address) public parentInviter;
//->
mapping(address => address[]) public childInviter;
//
uint256 public airdropAmount;
//
address public coin;
//
mapping (address => uint256) public profitOf;
//coin
uint256 public totalProfit;
//coin
uint256 public totalProfitReleased;
//BNB
mapping (address => uint256) public profitBNBOf;
uint256 public totalProfitBNB;
//BNB
uint256 public totalProfitBNBReleased;
//1BNB = ncoin
uint256 public swapRate;
uint256 public minBuy = 1e17;//BNB
uint256 public maxBuy = 5*1e18;//BNB
//BNB
mapping (address => uint256) public boughtOf;
//
uint256 public withdrawStartTime;
event SetAirdropAmount(uint256 oldAmount,uint256 newAmount);
event SetTotalCoinAmount(uint256 oldAmount,uint256 newAmount);
event SetSwapRate(uint256 oldSwapRate,uint256 newSwapRate);
event SetWithdrawStartTime(uint256 oldWithdrawStartTime,uint256 newWithdrawStartTime);
event ClaimAirdrop(address inviter,address inviterPa,uint256 airdropAmount);
event Buy(address user,address inviter,uint256 payAmount,uint256 outAmount);
constructor (address _coin,uint256 _airdropAmount,uint256 _swapRate,uint256 _withdrawStartTime,uint256 _totalCoinAmount) public {
require(_swapRate>0,"_swapRate error");
swapRate = _swapRate;
require(_withdrawStartTime>block.timestamp,"_withdrawStartTime error");
withdrawStartTime = _withdrawStartTime;
require(_coin!=address(0),"coin error");
coin = _coin;
require(_totalCoinAmount>0,"_totalCoinAmount error");
totalCoinAmount = _totalCoinAmount;
require(_airdropAmount>0,"_airdropAmount error");
airdropAmount = _airdropAmount;
_owner = msg.sender;
}
//
function withdrawETH(uint256 _amount) public onlyOwner {
require(_amount > 0, "withdrawETH: amount not good");
safeTransferETH(msg.sender, _amount);
}
//
function withdrawERC20(address _erc20, uint256 _amount) public onlyOwner {
require(_amount > 0, "withdrawERC20: amount not good");
safeErc20Transfer(_erc20, msg.sender, _amount);
}
function safeErc20Transfer(address _erc20 ,address _to, uint256 _amount) internal {
uint256 bal = IERC20(_erc20).balanceOf(address(this));
require(bal >= _amount,"safeErc20Transfer: _amount error");
IERC20(_erc20).transfer(_to, _amount);
}
function safeTransferETH(address to, uint256 value) internal {
require(address(this).balance >= value,"safeTransferETH: _amount error");
(bool success,) = to.call{value: value}(new bytes(0));
require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');
}
//
function getBalance() public view returns (uint256 coinBalance,uint256 bnbBalance,uint256 leftCoinAmount)
{
coinBalance = IERC20(coin).balanceOf(address(this));
bnbBalance = address(this).balance;
leftCoinAmount = totalCoinAmount.sub(totalProfit);
}
//
function setTotalCoinAmount(uint256 _amount) public onlyOwner {
require(_amount > 0 && totalCoinAmount!= _amount, "setTotalCoinAmount: _amount error");
uint256 _old = totalCoinAmount;
totalCoinAmount = _amount;
emit SetTotalCoinAmount(_old,_amount);
}
//
function setAirdropAmount(uint256 _amount) public onlyOwner {
require(_amount > 0 && airdropAmount!= _amount, "setAirdropAmount: _amount error");
uint256 _old = airdropAmount;
airdropAmount = _amount;
emit SetAirdropAmount(_old,_amount);
}
//
function setSwapRate(uint256 _swapRate) public onlyOwner {
require(_swapRate > 0 && swapRate!= _swapRate, "setAirdropAmount: _swapRate error");
uint256 _old = swapRate;
swapRate = _swapRate;
emit SetSwapRate(_old,_swapRate);
}
//
function setWithdrawStartTime(uint256 _withdrawStartTime) public onlyOwner {
require(_withdrawStartTime > 0 && withdrawStartTime!= _withdrawStartTime, "setWithdrawStartTime: _withdrawStartTime error");
uint256 _old = withdrawStartTime;
withdrawStartTime = _withdrawStartTime;
emit SetWithdrawStartTime(_old,_withdrawStartTime);
}
//
function claimAirdrop(address _inviter) external {
require(_inviter!=address(0),"buy: _inviter error");
if(parentInviter[msg.sender]==address(0)){
parentInviter[msg.sender] = _inviter;
childInviter[_inviter].push(msg.sender);
}
profitOf[msg.sender] = profitOf[msg.sender].add(airdropAmount);
uint256 one = airdropAmount.mul(1000).div(10000);//10%
uint256 two = airdropAmount.mul(500).div(10000);//5%
if(parentInviter[msg.sender]!=address(0) && one>0){
profitOf[parentInviter[msg.sender]] = profitOf[parentInviter[msg.sender]].add(one);
}
if(parentInviter[parentInviter[parentInviter[msg.sender]]]!=address(0) && two>0){
profitOf[parentInviter[parentInviter[msg.sender]]] = profitOf[parentInviter[parentInviter[msg.sender]]].add(two);
}
totalProfit = totalProfit.add(airdropAmount).add(one).add(two);
emit ClaimAirdrop(parentInviter[msg.sender],parentInviter[parentInviter[msg.sender]],airdropAmount);
}
//
function buy(address _inviter) external payable{
require(_inviter!=address(0),"buy: _inviter error");
require(msg.value>0,"buy: pay amount less than 0");
require(msg.value>=minBuy,"buy: pay amount less than minBuy");
require(boughtOf[msg.sender].add(msg.value)<=maxBuy,"buy: pay amount more than maxBuy");
if(parentInviter[msg.sender]==address(0)){
parentInviter[msg.sender] = _inviter;
childInviter[_inviter].push(msg.sender);
}
uint256 outAmount = msg.value.mul(swapRate);
require(outAmount>0,"buy: outAmount error");
profitOf[msg.sender] = profitOf[msg.sender].add(outAmount);
totalProfit = totalProfit.add(outAmount);
address lastPa = msg.sender;
uint8 count = 0;
for(uint256 i=0;i<20;i++){//20
if(count>=2){
break;
}
if(parentInviter[lastPa]==address(0)){
break;
}
if(boughtOf[parentInviter[lastPa]]>=5*1e17 && count==0){//0.5BNB
uint256 one = msg.value.mul(1000).div(10000);//10%
profitBNBOf[parentInviter[lastPa]] = profitBNBOf[parentInviter[lastPa]].add(one);
totalProfitBNB = totalProfitBNB.add(one);
count++;
}else if(count==1){
uint256 two = msg.value.mul(500).div(10000);//5%
profitBNBOf[parentInviter[lastPa]] = profitBNBOf[parentInviter[lastPa]].add(two);
totalProfitBNB = totalProfitBNB.add(two);
count++;
}
lastPa = parentInviter[lastPa];
}
//BNB
boughtOf[msg.sender] = boughtOf[msg.sender].add(msg.value);
emit Buy(msg.sender,_inviter,msg.value,outAmount);
}
//
function userWithdrawETH(uint256 _amount) external {
require(_amount > 0, "userWithdrawETH: _amount error 0");
require(profitBNBOf[msg.sender] >= _amount, "userWithdrawETH: _amount error");
profitBNBOf[msg.sender] = profitBNBOf[msg.sender].sub(_amount);
totalProfitBNBReleased = totalProfitBNBReleased.add(_amount);
safeTransferETH(msg.sender, _amount);
}
//
function userWithdrawERC20(uint256 _amount) external {
require(_amount > 0, "userWithdrawETH: _amount error 0");
require(profitOf[msg.sender] >= _amount, "userWithdrawERC20: _amount error");
require(block.timestamp>=withdrawStartTime,"userWithdrawERC20: paused");
profitOf[msg.sender] = profitOf[msg.sender].sub(_amount);
safeErc20Transfer(coin, msg.sender, _amount);
totalProfitReleased = totalProfitReleased.add(_amount);
}
function viewInviteeByAddress(address inviter,
uint256 cursor,
uint256 size)
external
view
returns (address[] memory generation,
uint256)
{
uint256 length = size;
if (length > childInviter[inviter].length - cursor) {
length = childInviter[inviter].length - cursor;
}
generation = new address[](length);
for (uint256 i = 0; i < length; i++) {
generation[i] = childInviter[inviter][i];
}
return (generation, cursor + length);
}
receive() external payable {
}
}
| 99,578 | 12,972 |
1a449807c316aa8959c50adcb0c8dc23d1191b31a6bd9ba04c5a65316e23f1a8
| 13,285 |
.sol
|
Solidity
| false |
474055172
|
brockelmore/memmove
|
52761dceb3b565ba3ef572ef81f30564d1a411e2
|
src/Array.sol
| 3,065 | 11,170 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.13 <0.9.0;
// create a user defined type that is a pointer to memory
type Array is bytes32;
library ArrayLib {
function newArray(uint256 capacityHint) internal pure returns (Array s) {
assembly ("memory-safe") {
// grab free mem ptr
s := mload(0x40)
// update free memory pointer based on array's layout:
// + 32 bytes for capacity
// + 32 bytes for current unset pointer/length
// + 32*capacity
// + current free memory pointer (s is equal to mload(0x40))
mstore(0x40, add(s, mul(add(0x02, capacityHint), 0x20)))
// store the capacity in the second word (see memory layout above)
mstore(add(0x20, s), capacityHint)
// store length as 0 because otherwise the compiler may have rugged us
mstore(s, 0x00)
}
}
// capacity of elements before a move would occur
function capacity(Array self) internal pure returns (uint256 cap) {
assembly ("memory-safe") {
cap := mload(add(0x20, self))
}
}
// number of set elements in the array
function length(Array self) internal pure returns (uint256 len) {
assembly ("memory-safe") {
len := mload(self)
}
}
// gets a ptr to an element
function unsafe_ptrToElement(Array self, uint256 index) internal pure returns (bytes32 ptr) {
assembly ("memory-safe") {
ptr := add(self, mul(0x20, add(0x02, index)))
}
}
// overloaded to default push function with 0 overallocation
function push(Array self, uint256 elem) internal view returns (Array ret) {
ret = push(self, elem, 0);
}
// returns the new pointer.
//
// method is *always* updating the pointer
function push(Array self, uint256 elem, uint256 overalloc) internal view returns (Array) {
Array ret;
assembly ("memory-safe") {
// set the return ptr
ret := self
// check if length == capacity (meaning no more preallocated space)
switch eq(mload(self), mload(add(0x20, self)))
case 1 {
// optimization: check if the free memory pointer is equal to the end of the preallocated space
// if it is, we can just natively extend the array because nothing has been allocated *after*
// us. i.e.:
// evm_memory = [00...free_mem_ptr...Array.length...Array.lastElement]
//
// to calculate where the last element it
switch eq(mload(0x40), add(self, mul(add(0x02, mload(self)), 0x20)))
case 1 {
// the free memory pointer hasn't moved, i.e. free_mem_ptr == Array.lastElement, just extend
// Add 1 to the Array.capacity
mstore(add(0x20, self), add(0x01, mload(add(0x20, self))))
// the free mem ptr is where we want to place the next element
mstore(mload(0x40), elem)
// move the free_mem_ptr by a word (32 bytes. 0x20 in hex)
mstore(0x40, add(0x20, mload(0x40)))
// update the length
mstore(self, add(0x01, mload(self)))
}
default {
// we couldn't do the above optimization, use the `identity` precompile to perform a memory move
// move the array to the free mem ptr by using the identity precompile which just returns the values
let array_size := mul(add(0x02, mload(self)), 0x20)
pop(staticcall(gas(), // pass gas
0x04, // call identity precompile address
self, // arg offset == pointer to self
array_size, // arg size: capacity + 2 * word_size (we add 2 to capacity to account for capacity and length words)
mload(0x40), // set return buffer to free mem ptr
array_size // identity just returns the bytes of the input so equal to argsize))
// add the element to the end of the array
mstore(add(mload(0x40), array_size), elem)
// add to the capacity
mstore(add(0x20, mload(0x40)), // free_mem_ptr + word == new capacity word
add(add(0x01, overalloc), mload(add(0x20, mload(0x40)))) // add one + overalloc to capacity)
// add to length
mstore(mload(0x40), add(0x01, mload(mload(0x40))))
// set the return ptr to the new array
ret := mload(0x40)
// update free memory pointer
// we also over allocate if requested
mstore(0x40, add(add(array_size, add(0x20, mul(overalloc, 0x20))), mload(0x40)))
}
}
default {
// we have capacity for the new element, store it
mstore(// mem_loc := capacity_ptr + (capacity + 2) * 32
// we add 2 to capacity to acct for capacity and length words, then multiply by element size
add(self, mul(add(0x02, mload(self)), 0x20)),
elem)
// update length
mstore(self, add(0x01, mload(self)))
}
}
return ret;
}
// used when you *guarantee* that the array has the capacity available to be pushed to.
// no need to update return pointer in this case
//
function unsafe_push(Array self, uint256 elem) internal pure {
assembly ("memory-safe") {
mstore(// mem_loc := capacity_ptr + (capacity + 2) * 32
// we add 2 to capacity to acct for capacity and length words, then multiply by element size
add(self, mul(add(0x02, mload(self)), 0x20)),
elem)
// update length
mstore(self, add(0x01, mload(self)))
}
}
// used when you *guarantee* that the index, i, is within the bounds of length
function unsafe_set(Array self, uint256 i, uint256 value) internal pure {
assembly ("memory-safe") {
mstore(add(self, mul(0x20, add(0x02, i))), value)
}
}
function set(Array self, uint256 i, uint256 value) internal pure {
// if the index is greater than or equal to the capacity, revert
assembly ("memory-safe") {
if lt(mload(add(0x20, self)), i) {
// emit compiler native Panic(uint256) style error
mstore(0x00, 0x4e487b7100000000000000000000000000000000000000000000000000000000)
mstore(0x04, 0x32)
revert(0, 0x24)
}
mstore(add(self, mul(0x20, add(0x02, i))), value)
}
}
// used when you *guarantee* that the index, i, is within the bounds of length
function unsafe_get(Array self, uint256 i) internal pure returns (uint256 s) {
assembly ("memory-safe") {
s := mload(add(self, mul(0x20, add(0x02, i))))
}
}
// a safe `get` that checks capacity
function get(Array self, uint256 i) internal pure returns (uint256 s) {
// if the index is greater than or equal to the capacity, revert
assembly ("memory-safe") {
if lt(mload(add(0x20, self)), i) {
// emit compiler native Panic(uint256) style error
mstore(0x00, 0x4e487b7100000000000000000000000000000000000000000000000000000000)
mstore(0x04, 0x32)
revert(0, 0x24)
}
s := mload(add(self, mul(0x20, add(0x02, i))))
}
}
function pop(Array self) internal pure returns (uint256 s) {
assembly ("memory-safe") {
let len := mload(self)
let last := add(self, mul(0x20, add(0x01, len)))
s := mload(last)
mstore(last, 0x00)
}
}
}
// A wrapper around the lower level array that does one layer of indirection so that the pointer
// because it doesnt need to. Slightly less efficient, generally adds 1-3 memops per func
library RefArrayLib {
using ArrayLib for Array;
function newArray(uint16 capacityHint) internal pure returns (Array s) {
Array referenced = ArrayLib.newArray(capacityHint);
assembly ("memory-safe") {
// grab free memory pointer for return value
s := mload(0x40)
// store referenced array in s
mstore(mload(0x40), referenced)
// update free mem ptr
mstore(0x40, add(mload(0x40), 0x20))
}
}
// capacity of elements before a move would occur
function capacity(Array self) internal pure returns (uint256 cap) {
assembly ("memory-safe") {
cap := mload(add(0x20, mload(self)))
}
}
// number of set elements in the array
function length(Array self) internal pure returns (uint256 len) {
assembly ("memory-safe") {
len := mload(mload(self))
}
}
// gets a ptr to an element
function unsafe_ptrToElement(Array self, uint256 index) internal pure returns (bytes32 ptr) {
assembly ("memory-safe") {
ptr := add(mload(self), mul(0x20, add(0x02, index)))
}
}
// overloaded to default push function with 0 overallocation
function push(Array self, uint256 elem) internal view {
push(self, elem, 0);
}
// dereferences the array
function deref(Array self) internal pure returns (Array s) {
assembly ("memory-safe") {
s := mload(self)
}
}
function push(Array self, uint256 elem, uint256 overalloc) internal view {
Array newArr = deref(self).push(elem, overalloc);
assembly ("memory-safe") {
// we always just update the pointer because it is cheaper to do so than check whether
// the array moved
mstore(self, newArr)
}
}
// used when you *guarantee* that the array has the capacity available to be pushed to.
// no need to update return pointer in this case
function unsafe_push(Array self, uint256 elem) internal pure {
// no need to update pointer
deref(self).unsafe_push(elem);
}
// used when you *guarantee* that the index, i, is within the bounds of length
function unsafe_set(Array self, uint256 i, uint256 value) internal pure {
deref(self).unsafe_set(i, value);
}
function set(Array self, uint256 i, uint256 value) internal pure {
deref(self).set(i, value);
}
// used when you *guarantee* that the index, i, is within the bounds of length
function unsafe_get(Array self, uint256 i) internal pure returns (uint256 s) {
s = deref(self).unsafe_get(i);
}
// a safe `get` that checks capacity
function get(Array self, uint256 i) internal pure returns (uint256 s) {
s = deref(self).get(i);
}
}
| 277,155 | 12,973 |
67efe791b70b84d7b0a9cb2a63f076c89490aa300c89b583de823e1ef3b9c45c
| 16,161 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/be/bef24ca4a790d333aaa9f3e89fff5ef3e47019f3_Distributor.sol
| 3,392 | 13,870 |
// SPDX-License-Identifier: AGPL-3.0-or-later
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));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
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);
}
}
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 ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable TIME;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
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 _time, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_time != address(0));
TIME = IERC20(_time);
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) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return TIME.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external 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 onlyOwner {
require(_recipient != address(0), "IA");
require(_rewardRate <= 5000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
require(_target <= 5000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 97,169 | 12,974 |
9bd1e654f37f688efb0a8c9133e998ec484f49d2b4ad98dc3c3d58be036ad02e
| 27,045 |
.sol
|
Solidity
| false |
327569421
|
QuickSwap/quickswap-core
|
27a8426ac90e4f34862483d6338b5febc79d99e0
|
contracts/staking/StakingRewardsFactory.sol
| 4,354 | 17,341 |
pragma solidity ^0.5.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract 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 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;
}
}
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;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library 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 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);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract 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, "ReentrancyGuard: reentrant call");
}
}
// Inheritance
interface IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward, uint256 duration) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
IUniswapV2ERC20(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward, uint256 rewardsDuration) external onlyRewardsDistribution updateReward(address(0)) {
require(block.timestamp.add(rewardsDuration) >= periodFinish, "Cannot reduce existing period");
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward, periodFinish);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward, uint256 periodFinish);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
}
interface IUniswapV2ERC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingRewardsFactory is Ownable {
// immutables
address public rewardsToken;
uint public stakingRewardsGenesis;
// the staking tokens for which the rewards contract has been deployed
address[] public stakingTokens;
// info about rewards for a particular staking token
struct StakingRewardsInfo {
address stakingRewards;
uint rewardAmount;
uint duration;
}
// rewards info by staking token
mapping(address => StakingRewardsInfo) public stakingRewardsInfoByStakingToken;
constructor(address _rewardsToken,
uint _stakingRewardsGenesis) Ownable() public {
require(_stakingRewardsGenesis >= block.timestamp, 'StakingRewardsFactory::constructor: genesis too soon');
rewardsToken = _rewardsToken;
stakingRewardsGenesis = _stakingRewardsGenesis;
}
///// permissioned functions
// deploy a staking reward contract for the staking token, and store the reward amount
// the reward will be distributed to the staking reward contract no sooner than the genesis
function deploy(address stakingToken, uint rewardAmount, uint256 rewardsDuration) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards == address(0), 'StakingRewardsFactory::deploy: already deployed');
info.stakingRewards = address(new StakingRewards(address(this), rewardsToken, stakingToken));
info.rewardAmount = rewardAmount;
info.duration = rewardsDuration;
stakingTokens.push(stakingToken);
}
function update(address stakingToken, uint rewardAmount, uint256 rewardsDuration) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0), 'StakingRewardsFactory::update: not deployed');
info.rewardAmount = rewardAmount;
info.duration = rewardsDuration;
}
///// permissionless functions
// call notifyRewardAmount for all staking tokens.
function notifyRewardAmounts() public {
require(stakingTokens.length > 0, 'StakingRewardsFactory::notifyRewardAmounts: called before any deploys');
for (uint i = 0; i < stakingTokens.length; i++) {
notifyRewardAmount(stakingTokens[i]);
}
}
// notify reward amount for an individual staking token.
// this is a fallback in case the notifyRewardAmounts costs too much gas to call for all contracts
function notifyRewardAmount(address stakingToken) public {
require(block.timestamp >= stakingRewardsGenesis, 'StakingRewardsFactory::notifyRewardAmount: not ready');
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0), 'StakingRewardsFactory::notifyRewardAmount: not deployed');
if (info.rewardAmount > 0 && info.duration > 0) {
uint rewardAmount = info.rewardAmount;
uint256 duration = info.duration;
info.rewardAmount = 0;
info.duration = 0;
require(IERC20(rewardsToken).transfer(info.stakingRewards, rewardAmount),
'StakingRewardsFactory::notifyRewardAmount: transfer failed');
StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount, duration);
}
}
function pullExtraTokens(address token, uint256 amount) external onlyOwner {
IERC20(token).transfer(msg.sender, amount);
}
}
| 225,859 | 12,975 |
3524ad41b5f4493fcc3734ac26e75e67f578ba015e1dd63a4848f3eae2a99646
| 12,918 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c5/C57C6D7C1FF8c17E658336d706320652292923eD_ManyStaker.sol
| 3,536 | 11,138 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract ManyStaker {
using SafeMath for uint256;
address private _owner;
uint256 constant public INVEST_MIN_AMOUNT = 10 ether;
uint256[] public REFERRAL_PERCENTS = [50, 25, 5];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public WITHDRAW_FEE = 1000; //In base point
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
address payable public insuranceWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable _commissionWallet, address payable _insuranceWallet, uint256 startDate) {
require(!isContract(_commissionWallet));
require(!isContract(_insuranceWallet));
commissionWallet = _commissionWallet;
insuranceWallet = _insuranceWallet;
if (startDate == 0) {
startUNIX = block.timestamp.add(10 days);
}else{
startUNIX = startDate;
}
_owner = msg.sender;
plans.push(Plan(14, 82));
plans.push(Plan(21, 76));
plans.push(Plan(28, 69));
plans.push(Plan(14, 82));
plans.push(Plan(21, 76));
plans.push(Plan(28, 69));
}
modifier onlyOwner() {
require(isOwner(), "Function accessible only by the owner !!");
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function setCommissionWallet(address payable _commissionWallet) external onlyOwner {
require(_commissionWallet != address(0), "invalid address");
commissionWallet = _commissionWallet;
}
function setInsuranceWallet(address payable _insuranceWallet) external onlyOwner {
require(_insuranceWallet != address(0), "invalid address");
insuranceWallet = _insuranceWallet;
}
function setStartUNIX(uint256 startDate) public onlyOwner {
require(block.timestamp < startUNIX, "contract has started");
require(startDate > block.timestamp, "Invalid startDate");
startUNIX = startDate;
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT, "Invalid invest amount");
require(plan < 6, "Invalid plan");
require(block.timestamp >= startUNIX, "contract hasn't started yet");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1); // TODDO: levels unuse
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function reinvest(uint8 plan) public {
require(plan < 6, "Invalid plan");
require(block.timestamp >= startUNIX, "contract hasn't started yet");
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 userReferralBonus = getUserReferralBonus(msg.sender);
if (userReferralBonus > 0) {
totalAmount = totalAmount.add(userReferralBonus);
user.bonus = 0;
}
require(totalAmount >= INVEST_MIN_AMOUNT, "Invalid invest amount");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, totalAmount);
user.deposits.push(Deposit(plan, percent, totalAmount, profit, block.timestamp, finish));
totalStaked = totalStaked.add(totalAmount);
emit NewDeposit(msg.sender, plan, percent, totalAmount, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
require(totalAmount > 0, "User has no dividends");
user.checkpoint = block.timestamp;
insuranceWallet.transfer(fees);
payable(msg.sender).transfer(totalAmount); // UPDATE: msg.sender -> payable(msg.sender)
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP)); // TODDO: test
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 74,691 | 12,976 |
bf459855b13d264450ce056d041096f2a66583702cac13ee59aafafc0cdfe59e
| 16,158 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6fe797963e0219e9c4162d333d82b357ded5297a.sol
| 3,992 | 15,924 |
pragma solidity >=0.4.25;
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC20Interface {
function allowance(address _from, address _to) public view returns(uint);
function transferFrom(address _from, address _to, uint _sum) public;
function transfer(address _to, uint _sum) public;
function balanceOf(address _owner) public view returns(uint);
}
contract WalletInterface {
function getTransaction(uint _id) public view returns(address, uint, address, uint, uint, bool);
}
contract ContractCreator {
function setContract() public returns(address);
}
contract MaxiCreditCompany {
event Transfer(address indexed _from, address indexed _to, uint _sum);
event TokenBoughtFromContract(address indexed _buyer, uint indexed _promoter, uint _sum);
event TokenBoughtFromSeller(address indexed _buyer, address _seller, uint _amount, uint indexed _offerId);
event Approval(address indexed _seller, address indexed _buyer, uint _amount);
event DescriptionChange(bytes32 _txt);
event NewServer(address indexed _serverAddress, uint indexed _id);
event ServerChanged(address indexed _newServerAddress, address indexed _oldServerAddress, uint indexed _id);
event ETHWithdraw(address indexed _to, uint _sum);
event ERC20Withdraw(address indexed _erc20Address, address indexed _to, uint _sum);
event SupplyIncreased(uint _amount, uint _totalSupply);
event NewSaleOffer(uint indexed saleOffersCounter, uint indexed _amount, uint indexed _unitPrice);
event SetToBuyBack(uint _amount, uint _price);
event BuyBack(uint indexed _amount, uint indexed buyBackPrice);
event SetOwner(uint indexed _id, address indexed _newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OwnerDeleted(uint indexed _id, address indexed _owner);
event OperatorRightChanged(address indexed _operator, uint _txRight);
event NewOperator(uint indexed _id, address indexed _newOperator, uint _txRight);
event OperatorChanged(uint indexed _id, address indexed _newOperator, address indexed oldOperator, uint _txRight);
event DeleteOperator(uint indexed _id, address indexed _operator);
event OwnerChangedPrice(uint _priceETH, uint _priceUSD);
event ServerChangedPrice(uint _priceETH, uint _priceUSD);
event NewContract(address indexed _addr, uint indexed newContractsLength);
using AddressUtils for address;
string public name = "MaxiCreditCompanyShare";
string public symbol = "MC2";
uint public supply = 80000000;
uint public decimals = 0;
bytes32 public description;
uint public unitPriceETH;
uint public unitPriceUSD;
uint public shareHoldersNumber;
mapping (address => uint) shareHolderId;
address[] public shareHolders;
bool shareHolderDelete;
address[10] public contractOwner;
address[10] public operator;
uint public ownerCounter;
mapping(address => bool) public isOwner;
mapping(address => bool) public isOperator;
mapping(address => uint) public operatorsRights;
mapping(address => uint) public balanceOf;
mapping(address => mapping(uint => uint)) public saleOffersByAddress;
mapping(uint => address) public saleOffersById;
mapping(uint => uint) public saleOffersAmount;
mapping(uint => uint) public saleOffersUnitPrice;
mapping(address => uint) public sellersOfferCounter;
uint public saleOffersCounter = 0;
uint public buyBackAmount = 0;
uint public buyBackPrice = 0;
mapping(address => mapping(address => uint)) public approvedTransfers;
address[] serverAddress;
mapping (address => bool) isOurServer;
uint serverAddressArrayLength;
ContractCreator cc;
address newContract;
address[] public newContracts;
uint public newContractsLength;
modifier onlyOwner() {
require(isOwner[msg.sender] == true);
require(msg.sender != address(0));
_;
}
modifier onlyOperator() {
require(isOperator[msg.sender] == true);
require(msg.sender != address(0));
_;
}
modifier onlyServer() {
require(isOurServer[msg.sender] == true);
require(msg.sender != address(0));
_;
}
constructor (uint _initPriceETH, uint _initPriceUSD) public {
contractOwner[0] = msg.sender;
isOwner[msg.sender] = true;
operator[0] = msg.sender;
isOperator[msg.sender] = true;
operatorsRights[msg.sender] = 100;
balanceOf[address(this)] = supply;
unitPriceETH = _initPriceETH;
unitPriceUSD = _initPriceUSD;
shareHoldersNumber = 0;
shareHolderDelete = false;
ownerCounter = 1;
}
function getContractOwner(uint _id) public view returns(address) {
return(contractOwner[_id]);
}
function setDescription(bytes32 _txt) public onlyOwner {
description = _txt;
emit DescriptionChange(_txt);
}
function setServerAddress(address _serverAddress) public onlyOwner {
serverAddressArrayLength = serverAddress.push(_serverAddress);
isOurServer[_serverAddress] = true;
emit NewServer(_serverAddress, serverAddressArrayLength - 1);
}
function modifyServer(uint _id, address _serverAddress) public onlyOwner {
address oldServer = serverAddress[_id];
isOurServer[serverAddress[_id]] = false;
serverAddress[_id] = _serverAddress;
isOurServer[_serverAddress] = true;
emit ServerChanged(_serverAddress, oldServer, _id);
}
function getServerAddressLength() public view onlyOperator returns(uint) {
return serverAddressArrayLength;
}
function getServerAddress(uint _num) public view onlyOperator returns(address) {
return serverAddress[_num];
}
function checkServerAddress(address _addr) public view onlyOperator returns(bool) {
return(isOurServer[_addr]);
}
function withdrawal(uint _sum, address _to) public onlyOperator {
require(operatorsRights[msg.sender] * address(this).balance / 100 >= _sum);
require(address(this).balance >= _sum);
require(_to != address(0) && _sum > 0);
address(_to).transfer(_sum);
emit ETHWithdraw(_to, _sum);
}
function withdrawERC20(address _erc20Address, address _to, uint _amount) public onlyOperator {
ERC20Interface ei = ERC20Interface(_erc20Address);
require(operatorsRights[msg.sender] * ei.balanceOf(this) / 100 >= _amount);
require(_erc20Address != address(0) && _to != address(0));
ei.transfer(_to, _amount);
emit ERC20Withdraw(_erc20Address, _to, _amount);
}
function totalSupply() public view returns(uint) {
return(supply);
}
function increaseSupply(uint _amount) public onlyOwner {
supply += _amount;
balanceOf[this] += _amount;
emit SupplyIncreased(_amount, supply);
}
function _transfer(address _from, address _to, uint _sum) private {
require(_from != address(0));
require(_to != address(0));
require(_from != _to);
require(_sum > 0);
require(balanceOf[_from] >= _sum);
require(balanceOf[_to] + _sum >= _sum);
if(balanceOf[_to] == 0) {
shareHolderId[_to] = shareHoldersNumber;
if(shareHolderDelete) {
shareHolders[shareHoldersNumber] = _to;
shareHolderDelete = false;
} else {
shareHolders.push(_to);
}
shareHoldersNumber ++;
}
uint sumBalanceBeforeTx = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _sum;
balanceOf[_to] += _sum;
if(balanceOf[_from] == 0) {
shareHoldersNumber --;
shareHolders[shareHolderId[_from]] = shareHolders[shareHoldersNumber];
shareHolderId[shareHolders[shareHoldersNumber]] = shareHolderId[_from];
delete shareHolders[shareHoldersNumber];
shareHolderDelete = true;
}
assert(sumBalanceBeforeTx == balanceOf[_from] + balanceOf[_to]);
emit Transfer(_from, _to, _sum);
}
function transfer(address _to, uint _sum) external returns(bool) {
_transfer(msg.sender, _to, _sum);
return(true);
}
function transferFromContractsBalance(address _to, uint _sum) public onlyOwner {
require(_to != address(0));
require(this != _to);
require(_sum > 0);
require(balanceOf[this] >= _sum);
require(balanceOf[_to] + _sum >= _sum);
if(balanceOf[_to] == 0) {
shareHolderId[_to] = shareHoldersNumber;
if(shareHolderDelete) {
shareHolders[shareHoldersNumber] = _to;
shareHolderDelete = false;
} else {
shareHolders.push(_to);
}
shareHoldersNumber ++;
}
uint sumBalanceBeforeTx = balanceOf[this] + balanceOf[_to];
balanceOf[this] -= _sum;
balanceOf[_to] += _sum;
assert(sumBalanceBeforeTx == balanceOf[this] + balanceOf[_to]);
emit Transfer(this, _to, _sum);
}
function setToSale(uint _amount, uint _unitPrice) public {
require(balanceOf[msg.sender] >= _amount);
require(_unitPrice > 0);
saleOffersByAddress[msg.sender][sellersOfferCounter[msg.sender]] = saleOffersCounter;
saleOffersById[saleOffersCounter] = msg.sender;
saleOffersAmount[saleOffersCounter] = _amount;
saleOffersUnitPrice[saleOffersCounter] = _unitPrice;
emit NewSaleOffer(saleOffersCounter, _amount, _unitPrice);
sellersOfferCounter[msg.sender] ++;
saleOffersCounter ++;
}
function getSaleOffer(uint _id) public view returns(address, uint, uint) {
return(saleOffersById[_id], saleOffersAmount[_id], saleOffersUnitPrice[_id]);
}
function buyFromSeller(uint _amount, uint _offerId) public payable {
require(saleOffersAmount[_offerId] >= _amount);
uint orderPrice = _amount * saleOffersUnitPrice[_offerId];
require(msg.value == orderPrice);
saleOffersAmount[_offerId] -= _amount;
_transfer(saleOffersById[_offerId], msg.sender, _amount);
uint sellersShare = orderPrice * 99 / 100;
uint toSend = sellersShare;
sellersShare = 0;
saleOffersById[_offerId].transfer(toSend);
emit TokenBoughtFromSeller(msg.sender, saleOffersById[_offerId], _amount, _offerId);
}
function setBuyBack(uint _amount, uint _price) public onlyOperator {
buyBackAmount += _amount;
buyBackPrice = _price;
emit SetToBuyBack(_amount, _price);
}
function buyback(uint _amount) public {
require(buyBackAmount >= _amount);
buyBackAmount -= _amount;
_transfer(msg.sender, this, _amount);
msg.sender.transfer(_amount * buyBackPrice);
emit BuyBack(_amount, buyBackPrice);
}
function getETH(uint _amount) public payable {
require(msg.value == _amount);
//event?
}
//should be different function for set and modify owner and operator
function setContractOwner(uint _id, address _newOwner) public onlyOwner {
require(contractOwner[_id] == address(0) && !isOwner[_newOwner]);
contractOwner[_id] = _newOwner;
isOwner[_newOwner] = true;
ownerCounter++;
emit SetOwner(_id, _newOwner);
}
function modifyContractOwner(uint _id, address _newOwner) public onlyOwner {
require(contractOwner[_id] != address(0) && contractOwner[_id] != _newOwner);
address previousOwner = contractOwner[_id];
isOwner[contractOwner[_id]] = false;
contractOwner[_id] = _newOwner;
isOwner[_newOwner] = true;
emit OwnershipTransferred(previousOwner, _newOwner);
}
function deleteOwner(uint _id, address _addr) public onlyOwner {
require(ownerCounter > 1);
require(isOwner[_addr] && contractOwner[_id] == _addr);
isOwner[_addr] = false;
contractOwner[_id] = address(0);
ownerCounter--;
emit OwnerDeleted(_id, _addr);
}
function setOperatorsRight(address _operator, uint _txRight) public onlyOwner {
require(_txRight <= 100 && isOperator[_operator]);
operatorsRights[_operator] = _txRight;
emit OperatorRightChanged(_operator, _txRight);
}
function setOperator(uint _id, address _newOperator, uint _txRight) public onlyOwner {
require(_txRight <= 100 && operator[_id] == address(0) && !isOperator[_newOperator]);
operator[_id] = _newOperator;
operatorsRights[_newOperator] = _txRight;
isOperator[_newOperator] = true;
emit NewOperator(_id, _newOperator, _txRight);
}
function modifyOperator(uint _id, address _newOperator, uint _txRight) public onlyOwner {
require(operator[_id] != address(0) && operator[_id] != _newOperator && _txRight < 100);
address oldOperator = operator[_id];
isOperator[operator[_id]] = false;
operatorsRights[operator[_id]] = 0;
isOperator[_newOperator] = true;
operator[_id] = _newOperator;
operatorsRights[_newOperator] = _txRight;
emit OperatorChanged(_id, _newOperator, oldOperator, _txRight);
}
function deleteOperator(uint _id, address _operator) public onlyOwner {
require(isOperator[_operator] && operator[_id] == _operator);
isOperator[_operator] = false;
operatorsRights[_operator] = 0;
operator[_id] = address(0);
emit DeleteOperator(_id, _operator);
}
function getShareNumber(address _addr) public view returns(uint) {
return(balanceOf[_addr]);
}
function approve(address _to, uint _sum) public {
approvedTransfers[msg.sender][_to] += _sum;
emit Approval(msg.sender, _to, _sum);
}
function allowance(address _from, address _to) public view returns(uint) {
return (approvedTransfers[_from][_to]);
}
function transferFrom(address _from, address _to, uint _sum) public {
require(approvedTransfers[_from][msg.sender] >= _sum);
approvedTransfers[_from][msg.sender] -= _sum;
_transfer(_from, _to, _sum);
}
function changePriceByOwner(uint _priceETH, uint _priceUSD) public onlyOwner {
require(_priceETH > 0 && _priceUSD > 0);
unitPriceETH = _priceETH;
unitPriceUSD = _priceUSD;
emit OwnerChangedPrice(_priceETH, _priceUSD);
}
function changePriceByServer(uint _priceETH, uint _priceUSD) public onlyServer {
require(_priceETH > 0 && _priceUSD > 0);
unitPriceETH = _priceETH;
unitPriceUSD = _priceUSD;
emit ServerChangedPrice(_priceETH, _priceUSD);
}
function checkIsShareHolder() public view returns(bool){
if(balanceOf[msg.sender] > 0) {
return(true);
} else {
return(false);
}
}
function getShareHolderRegister() public view returns(address[] memory) {
return(shareHolders);
}
function setNewContract(address _addr) public onlyOperator {
cc = ContractCreator(_addr);
newContract = cc.setContract();
newContracts.push(newContract);
newContractsLength ++;
emit NewContract(_addr, newContractsLength);
}
}
| 188,462 | 12,977 |
70f5ce19f01a71519f30d6c60711a6d7d264bc8d47c32f4c9166806e4c0dba5c
| 18,234 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x0809bd190c94f4408e691c410e67bff0df5d225d.sol
| 2,885 | 10,099 |
pragma solidity 0.4.21;
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 Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
}
function remove(Role storage role, address addr)
internal
{
role.bearer[addr] = false;
}
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
}
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
}
}
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address addr, string roleName);
event RoleRemoved(address addr, string roleName);
string public constant ROLE_ADMIN = "admin";
function RBAC()
public
{
addRole(msg.sender, ROLE_ADMIN);
}
function checkRole(address addr, string roleName)
view
public
{
roles[roleName].check(addr);
}
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
}
function adminAddRole(address addr, string roleName)
onlyAdmin
public
{
addRole(addr, roleName);
}
function adminRemoveRole(address addr, string roleName)
onlyAdmin
public
{
removeRole(addr, roleName);
}
function addRole(address addr, string roleName)
internal
{
roles[roleName].add(addr);
emit RoleAdded(addr, roleName);
}
function removeRole(address addr, string roleName)
internal
{
roles[roleName].remove(addr);
emit RoleRemoved(addr, roleName);
}
modifier onlyRole(string roleName)
{
checkRole(msg.sender, roleName);
_;
}
modifier onlyAdmin()
{
checkRole(msg.sender, ROLE_ADMIN);
_;
}
}
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);
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) {
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 CryptoniaToken is StandardToken, RBAC {
string public name = "Cryptonia Poker Chips";
string public symbol = "CPC";
uint8 public decimals = 2;
uint256 public cap = 100000000000;
bool public mintingFinished = false;
string constant ROLE_MINTER = "minter";
event Mint(address indexed to, uint256 amount);
event MintFinished();
event Burn(address indexed burner, uint256 value);
function mint(address _to, uint256 _amount) onlyRole(ROLE_MINTER) public returns (bool) {
require(!mintingFinished);
require(totalSupply_.add(_amount) <= cap);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyAdmin public returns (bool) {
require(!mintingFinished);
mintingFinished = true;
emit MintFinished();
return true;
}
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, address(0), _value);
}
}
contract CryptoniaCrowdsale is RBAC {
using SafeMath for uint256;
struct Phase {
uint256 startDate;
uint256 endDate;
uint256 tokensPerETH;
uint256 tokensIssued;
}
Phase[] public phases;
// The token being sold
CryptoniaToken public token;
// Address where funds get collected
address public wallet;
// Minimal allowed purchase is 0.1 ETH
uint256 public minPurchase = 100000000000000000;
// Amount of ETH raised in wei. 1 wei is 10e-18 ETH
uint256 public weiRaised;
// Amount of tokens issued by this contract
uint256 public tokensIssued;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event PhaseAdded(address indexed sender, uint256 index, uint256 startDate, uint256 endDate, uint256 tokensPerETH);
event PhaseDeleted(address indexed sender, uint256 index);
event WalletChanged(address newWallet);
event OracleChanged(address newOracle);
function CryptoniaCrowdsale(address _wallet, CryptoniaToken _token) public {
require(_wallet != address(0));
require(_token != address(0));
wallet = _wallet;
token = _token;
}
function() external payable {
uint256 weiAmount = msg.value;
address beneficiary = msg.sender;
uint256 currentPhaseIndex = getCurrentPhaseIndex();
uint256 tokens = weiAmount.mul(phases[currentPhaseIndex].tokensPerETH).div(1 ether);
require(beneficiary != address(0));
require(weiAmount >= minPurchase);
weiRaised = weiRaised.add(weiAmount);
phases[currentPhaseIndex].tokensIssued = phases[currentPhaseIndex].tokensIssued.add(tokens);
tokensIssued = tokensIssued.add(tokens);
token.mint(beneficiary, tokens);
wallet.transfer(msg.value);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
function validatePhaseDates(uint256 _startDate, uint256 _endDate) view public returns (bool) {
if (_endDate <= _startDate) {
return false;
}
for (uint i = 0; i < phases.length; i++) {
if (_startDate >= phases[i].startDate && _startDate <= phases[i].endDate) {
return false;
}
if (_endDate >= phases[i].startDate && _endDate <= phases[i].endDate) {
return false;
}
}
return true;
}
function addPhase(uint256 _startDate, uint256 _endDate, uint256 _tokensPerETH) public onlyAdmin {
require(validatePhaseDates(_startDate, _endDate));
require(_tokensPerETH > 0);
phases.push(Phase(_startDate, _endDate, _tokensPerETH, 0));
uint256 index = phases.length - 1;
emit PhaseAdded(msg.sender, index, _startDate, _endDate, _tokensPerETH);
}
function delPhase(uint256 index) public onlyAdmin {
require (index < phases.length);
for (uint i = index; i < phases.length - 1; i++) {
phases[i] = phases[i + 1];
}
phases.length--;
emit PhaseDeleted(msg.sender, index);
}
function getCurrentPhaseIndex() view public returns (uint256) {
for (uint i = 0; i < phases.length; i++) {
if (phases[i].startDate <= now && now <= phases[i].endDate) {
return i;
}
}
revert();
}
function setWallet(address _newWallet) onlyAdmin public {
require(_newWallet != address(0));
wallet = _newWallet;
emit WalletChanged(_newWallet);
}
}
| 188,531 | 12,978 |
240f8df899799c6bc11ceb4201589ee3130b79e410aed6ce953aeb2ae91c582a
| 10,934 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdfdc0d82d96f8fd40ca0cfb4a288955becec2088.sol
| 2,453 | 9,442 |
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
pragma solidity ^0.4.23;
contract Token {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
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 constant returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract Owned {
/// `owner` is the only address that can call a function with this
/// modifier
modifier isOwner() {
require(msg.sender == owner);
_;
}
address public owner;
/// @notice The constructor assigns the message sender to be `owner`
constructor() public {
owner = msg.sender;
}
address newOwner=0x0;
event OwnerUpdate(address _prevOwner, address _newOwner);
///change the owner
function changeOwner(address _newOwner) public isOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
/// accept the ownership
function acceptOwnership() public{
require(msg.sender == newOwner);
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract Controlled is Owned{
constructor() public {
setExclude(msg.sender);
}
// Flag that determines if the token is transferable or not.
bool public transferEnabled = false;
// flag that makes locked address effect
bool public lockFlag=true;
mapping(address => bool) public locked;
mapping(address => bool) public exclude;
function enableTransfer(bool _enable) public isOwner{
transferEnabled=_enable;
}
function disableLock(bool _enable) public isOwner returns (bool success){
lockFlag=_enable;
return true;
}
function addLock(address _addr) public isOwner returns (bool success){
require(_addr!=msg.sender);
locked[_addr]=true;
return true;
}
function setExclude(address _addr) public isOwner returns (bool success){
exclude[_addr]=true;
return true;
}
function removeLock(address _addr) public isOwner returns (bool success){
locked[_addr]=false;
return true;
}
modifier transferAllowed(address _addr) {
if (!exclude[_addr]) {
assert(transferEnabled);
if(lockFlag){
assert(!locked[_addr]);
}
}
_;
}
modifier validAddress(address _addr) {
assert(0x0 != _addr && 0x0 != msg.sender);
_;
}
}
contract StandardToken is Token,Controlled {
function transfer(address _to, uint256 _value) public transferAllowed(msg.sender) validAddress(_to) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
require(_value > 0);
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) public transferAllowed(_from) validAddress(_to) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
require(_value > 0);
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(_value > 0);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract MTC is StandardToken {
function () public {
revert();
}
using SafeMath for uint256;
string public name = "MTC Mesh Network";
uint8 public decimals = 18;
string public symbol = "MTC";
// The nonce for avoid transfer replay attacks
mapping(address => uint256) nonces;
constructor (uint256 initialSupply) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
}
function setName(string _name) isOwner public {
name = _name;
}
function transferProxy(address _from, address _to, uint256 _value, uint256 _fee,
uint8 _v,bytes32 _r, bytes32 _s) public transferAllowed(_from) returns (bool){
require(_value > 0);
if(balances[_from] < _fee.add(_value)) revert();
uint256 nonce = nonces[_from];
bytes32 h = keccak256(_from,_to,_value,_fee,nonce);
if(_from != ecrecover(h,_v,_r,_s)) revert();
if(balances[_to].add(_value) < balances[_to]
|| balances[msg.sender].add(_fee) < balances[msg.sender]) revert();
balances[_to] += _value;
emit Transfer(_from, _to, _value);
balances[msg.sender] += _fee;
emit Transfer(_from, msg.sender, _fee);
balances[_from] -= _value.add(_fee);
nonces[_from] = nonce + 1;
return true;
}
function approveProxy(address _from, address _spender, uint256 _value,
uint8 _v,bytes32 _r, bytes32 _s) public returns (bool success) {
require(_value > 0);
uint256 nonce = nonces[_from];
bytes32 hash = keccak256(_from,_spender,_value,nonce);
if(_from != ecrecover(hash,_v,_r,_s)) revert();
allowed[_from][_spender] = _value;
emit Approval(_from, _spender, _value);
nonces[_from] = nonce + 1;
return true;
}
function getNonce(address _addr) public constant returns (uint256){
return nonces[_addr];
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
if(!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { revert(); }
return true;
}
function approveAndCallcode(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
//Call the contract code
if(!_spender.call(_extraData)) { revert(); }
return true;
}
// Allocate tokens to the users
// @param _owners The owners list of the token
// @param _values The value list of the token
function allocateTokens(address[] _owners, uint256[] _values) public isOwner {
if(_owners.length != _values.length) revert();
for(uint256 i = 0; i < _owners.length ; i++){
address to = _owners[i];
uint256 value = _values[i];
balances[owner] -= value;
balances[to] += value;
}
}
}
| 222,323 | 12,979 |
f2da8955cbc9bbf65262517ffbc74d6245776b87bef24a0a050b615273e026d3
| 25,877 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/LQID-0x3732713f81a308885e209b23388755b5bb5097b1.sol
| 4,702 | 17,074 |
// liquid.finance (LQID)
// LQID, its DeFi but for the third generation
// LQID is a fresh frictionless yield farming financial tool built for the DeFi age
//| $$ /$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$
//| $$ |_ $$_/ /$$__ $$| $$ | $$|_ $$_/| $$__ $$
//| $$ | $$ | $$ \ $$| $$ | $$ | $$ | $$ \ $$
//| $$ | $$ | $$ | $$| $$ | $$ | $$ | $$ | $$
//| $$ | $$ | $$ | $$| $$ | $$ | $$ | $$ | $$
//| $$ | $$ | $$/$$ $$| $$ | $$ | $$ | $$ | $$
//| $$$$$$$$ /$$$$$$| $$$$$$/| $$$$$$/ /$$$$$$| $$$$$$$/
//|________/|______/ \____ $$$ \______/ |______/|_______/
// \__/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract 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 LQID is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 20 * 10**9 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'liquid.finance';
string private _symbol = 'LQID';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(4);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 188,529 | 12,980 |
ad6cd9899bb1e24263b3d97f088b2c679b5e4d42426d7e56b22eaa2dff99e7f8
| 14,181 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x98278eb74b388efd4d6fc81dd3f95b642ce53f2b.sol
| 3,743 | 13,377 |
pragma solidity ^0.4.25;
contract Army {
GooToken constant goo = GooToken(0xdf0960778c6e6597f197ed9a25f12f5d971da86c);
Clans clans = Clans(0x0);
uint224 public totalArmyPower; // Global power of players (attack + defence)
uint224 public gooBankroll; // Goo dividends to be split over time between clans/players' army power
uint256 public nextSnapshotTime;
address public owner; // Minor management of game
mapping(address => mapping(uint256 => ArmyPower)) public armyPowerSnapshots; // Store player's army power for given day (snapshot)
mapping(address => mapping(uint256 => bool)) public armyPowerZeroedSnapshots; // Edgecase to determine difference between 0 army and an unused/inactive day.
mapping(address => uint256) public lastWarFundClaim; // Days (snapshot number)
mapping(address => uint256) public lastArmyPowerUpdate; // Days (last snapshot) player's army was updated
mapping(address => bool) operator;
uint224[] public totalArmyPowerSnapshots; // The total player army power for each prior day past
uint224[] public allocatedWarFundSnapshots; // Div pot (goo allocated to each prior day past)
uint224 public playerDivPercent = 2;
uint224 public clanDivPercent = 2;
struct ArmyPower {
uint80 attack;
uint80 defense;
uint80 looting;
}
constructor(uint256 firstSnapshotTime) public {
nextSnapshotTime = firstSnapshotTime;
owner = msg.sender;
}
function setClans(address clansContract) external {
require(msg.sender == owner);
clans = Clans(clansContract);
}
function setOperator(address gameContract, bool isOperator) external {
require(msg.sender == owner);
operator[gameContract] = isOperator;
}
function updateDailyDivPercents(uint224 newPlayersPercent, uint224 newClansPercent) external {
require(msg.sender == owner);
require(newPlayersPercent > 0 && newPlayersPercent <= 10); // 1-10% daily
require(newClansPercent > 0 && newClansPercent <= 10); // 1-10% daily
playerDivPercent = newPlayersPercent;
clanDivPercent = newClansPercent;
}
function depositSpentGoo(uint224 gooSpent) external {
require(operator[msg.sender]);
gooBankroll += gooSpent;
}
function getArmyPower(address player) external view returns (uint80, uint80, uint80) {
ArmyPower memory armyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
return (armyPower.attack, armyPower.defense, armyPower.looting);
}
// Convenience function
function getArmiesPower(address player, address target) external view returns (uint80 playersAttack, uint80 playersLooting, uint80 targetsDefense) {
ArmyPower memory armyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
playersAttack = armyPower.attack;
playersLooting = armyPower.looting;
targetsDefense = armyPowerSnapshots[target][lastArmyPowerUpdate[target]].defense;
}
function increasePlayersArmyPowerTrio(address player, uint80 attackGain, uint80 defenseGain, uint80 lootingGain) public {
require(operator[msg.sender]);
ArmyPower memory existingArmyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
uint256 snapshotDay = allocatedWarFundSnapshots.length;
// Adjust army power (reusing struct)
existingArmyPower.attack += attackGain;
existingArmyPower.defense += defenseGain;
existingArmyPower.looting += lootingGain;
armyPowerSnapshots[player][snapshotDay] = existingArmyPower;
if (lastArmyPowerUpdate[player] != snapshotDay) {
lastArmyPowerUpdate[player] = snapshotDay;
}
totalArmyPower += (attackGain + defenseGain);
clans.increaseClanPower(player, attackGain + defenseGain);
}
function decreasePlayersArmyPowerTrio(address player, uint80 attackLoss, uint80 defenseLoss, uint80 lootingLoss) public {
require(operator[msg.sender]);
ArmyPower memory existingArmyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
uint256 snapshotDay = allocatedWarFundSnapshots.length;
// Adjust army power (reusing struct)
existingArmyPower.attack -= attackLoss;
existingArmyPower.defense -= defenseLoss;
existingArmyPower.looting -= lootingLoss;
if (existingArmyPower.attack == 0 && existingArmyPower.defense == 0) { // Special case which tangles with "inactive day" snapshots (claiming divs)
armyPowerZeroedSnapshots[player][snapshotDay] = true;
delete armyPowerSnapshots[player][snapshotDay]; // 0
} else {
armyPowerSnapshots[player][snapshotDay] = existingArmyPower;
}
if (lastArmyPowerUpdate[player] != snapshotDay) {
lastArmyPowerUpdate[player] = snapshotDay;
}
totalArmyPower -= (attackLoss + defenseLoss);
clans.decreaseClanPower(player, attackLoss + defenseLoss);
}
function changePlayersArmyPowerTrio(address player, int attackChange, int defenseChange, int lootingChange) public {
require(operator[msg.sender]);
ArmyPower memory existingArmyPower = armyPowerSnapshots[player][lastArmyPowerUpdate[player]];
uint256 snapshotDay = allocatedWarFundSnapshots.length;
// Allow change to be positive or negative
existingArmyPower.attack = uint80(int(existingArmyPower.attack) + attackChange);
existingArmyPower.defense = uint80(int(existingArmyPower.defense) + defenseChange);
existingArmyPower.looting = uint80(int(existingArmyPower.looting) + lootingChange);
if (existingArmyPower.attack == 0 && existingArmyPower.defense == 0) { // Special case which tangles with "inactive day" snapshots (claiming divs)
armyPowerZeroedSnapshots[player][snapshotDay] = true;
delete armyPowerSnapshots[player][snapshotDay]; // 0
} else {
armyPowerSnapshots[player][snapshotDay] = existingArmyPower;
}
if (lastArmyPowerUpdate[player] != snapshotDay) {
lastArmyPowerUpdate[player] = snapshotDay;
}
changeTotalArmyPower(player, attackChange, defenseChange);
}
function changeTotalArmyPower(address player, int attackChange, int defenseChange) internal {
uint224 newTotal = uint224(int(totalArmyPower) + attackChange + defenseChange);
if (newTotal > totalArmyPower) {
clans.increaseClanPower(player, newTotal - totalArmyPower);
} else if (newTotal < totalArmyPower) {
clans.decreaseClanPower(player, totalArmyPower - newTotal);
}
totalArmyPower = newTotal;
}
// Allocate army power divs for the day (00:00 cron job)
function snapshotDailyWarFunding() external {
require(msg.sender == owner);
require(now + 6 hours > nextSnapshotTime);
totalArmyPowerSnapshots.push(totalArmyPower);
allocatedWarFundSnapshots.push((gooBankroll * playerDivPercent) / 100);
uint256 allocatedClanWarFund = (gooBankroll * clanDivPercent) / 100; // No daily snapshots needed for Clans (as below will also claim between the handful of clans)
gooBankroll -= (gooBankroll * (playerDivPercent + clanDivPercent)) / 100; // % of pool daily
uint256 numClans = clans.totalSupply();
uint256[] memory clanArmyPower = new uint256[](numClans);
// Get total power from all clans
uint256 todaysTotalClanPower;
for (uint256 i = 1; i <= numClans; i++) {
clanArmyPower[i-1] = clans.clanTotalArmyPower(i);
todaysTotalClanPower += clanArmyPower[i-1];
}
// Distribute goo divs to clans based on their relative power
for (i = 1; i <= numClans; i++) {
clans.depositGoo((allocatedClanWarFund * clanArmyPower[i-1]) / todaysTotalClanPower, i);
}
nextSnapshotTime = now + 24 hours;
}
function claimWarFundDividends(uint256 startSnapshot, uint256 endSnapShot) external {
require(startSnapshot <= endSnapShot);
require(startSnapshot >= lastWarFundClaim[msg.sender]);
require(endSnapShot < allocatedWarFundSnapshots.length);
uint224 gooShare;
ArmyPower memory previousArmyPower = armyPowerSnapshots[msg.sender][lastWarFundClaim[msg.sender] - 1]; // Underflow won't be a problem as armyPowerSnapshots[][0xffffffff] = 0;
for (uint256 i = startSnapshot; i <= endSnapShot; i++) {
// Slightly complex things by accounting for days/snapshots when user made no tx's
ArmyPower memory armyPowerDuringSnapshot = armyPowerSnapshots[msg.sender][i];
bool soldAllArmy = armyPowerZeroedSnapshots[msg.sender][i];
if (!soldAllArmy && armyPowerDuringSnapshot.attack == 0 && armyPowerDuringSnapshot.defense == 0) {
armyPowerDuringSnapshot = previousArmyPower;
} else {
previousArmyPower = armyPowerDuringSnapshot;
}
gooShare += (allocatedWarFundSnapshots[i] * (armyPowerDuringSnapshot.attack + armyPowerDuringSnapshot.defense)) / totalArmyPowerSnapshots[i];
}
ArmyPower memory endSnapshotArmyPower = armyPowerSnapshots[msg.sender][endSnapShot];
if (endSnapshotArmyPower.attack == 0 && endSnapshotArmyPower.defense == 0 && !armyPowerZeroedSnapshots[msg.sender][endSnapShot] && (previousArmyPower.attack + previousArmyPower.defense) > 0) {
armyPowerSnapshots[msg.sender][endSnapShot] = previousArmyPower; // Checkpoint for next claim
}
lastWarFundClaim[msg.sender] = endSnapShot + 1;
(uint224 clanFee, uint224 leaderFee, address leader, uint224 referalFee, address referer) = clans.getPlayerFees(msg.sender);
if (clanFee > 0) {
clanFee = (gooShare * clanFee) / 100; // Convert from percent to goo
leaderFee = (gooShare * leaderFee) / 100; // Convert from percent to goo
clans.mintGoo(msg.sender, clanFee);
goo.mintGoo(leaderFee, leader);
}
if (referer == address(0)) {
referalFee = 0;
} else if (referalFee > 0) {
referalFee = (gooShare * referalFee) / 100; // Convert from percent to goo
goo.mintGoo(referalFee, referer);
}
goo.mintGoo(gooShare - (clanFee + leaderFee + referalFee), msg.sender);
}
function getSnapshotDay() external view returns (uint256 snapshot) {
snapshot = allocatedWarFundSnapshots.length;
}
}
contract GooToken {
function transfer(address to, uint256 tokens) external returns (bool);
function increasePlayersGooProduction(address player, uint256 increase) external;
function decreasePlayersGooProduction(address player, uint256 decrease) external;
function updatePlayersGooFromPurchase(address player, uint224 purchaseCost) external;
function updatePlayersGoo(address player) external;
function mintGoo(uint224 amount, address player) external;
}
contract Clans {
mapping(uint256 => uint256) public clanTotalArmyPower;
function totalSupply() external view returns (uint256);
function depositGoo(uint256 amount, uint256 clanId) external;
function getPlayerFees(address player) external view returns (uint224 clansFee, uint224 leadersFee, address leader, uint224 referalsFee, address referer);
function getPlayersClanUpgrade(address player, uint256 upgradeClass) external view returns (uint224 upgradeGain);
function mintGoo(address player, uint256 amount) external;
function increaseClanPower(address player, uint256 amount) external;
function decreaseClanPower(address player, uint256 amount) external;
}
contract Factories {
uint256 public constant MAX_SIZE = 40;
function getFactories(address player) external returns (uint256[]);
function addFactory(address player, uint8 position, uint256 unitId) external;
}
library SafeMath {
function mul(uint224 a, uint224 b) internal pure returns (uint224) {
if (a == 0) {
return 0;
}
uint224 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 SafeMath224 {
function mul(uint224 a, uint224 b) internal pure returns (uint224) {
if (a == 0) {
return 0;
}
uint224 c = a * b;
assert(c / a == b);
return c;
}
function div(uint224 a, uint224 b) internal pure returns (uint224) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint224 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint224 a, uint224 b) internal pure returns (uint224) {
assert(b <= a);
return a - b;
}
function add(uint224 a, uint224 b) internal pure returns (uint224) {
uint224 c = a + b;
assert(c >= a);
return c;
}
}
| 202,515 | 12,981 |
468cde96d365516424b1b03c1e65c35472aa00730a100f8eaeb2d496f015a70e
| 22,225 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x21ae174c592cbb476819344a895d0e9219f5cc79.sol
| 7,618 | 21,297 |
pragma solidity ^0.4.24;
contract BO3Kevents {
event onBuying (address indexed _addr,
uint256 ethAmount,
uint256 flagAmount,
uint256 playerFlags,
uint256 ethOfRound,
uint256 keysOfRound,
uint256 potOfRound);
event onTimeAdding(uint256 startTime,
uint256 endTime,
uint256 newTimeInterval,
uint256 currentInterval);
event onDiscount(address indexed _addr,
uint256 randomValue,
uint256 discountValue,
bool getDiscount);
event onRoundEnding(address indexed winnerAddr,
uint teamID,
uint256 winValue,
uint256 soldierValue,
uint256 teamValue,
uint256 nextRoundStartTime,
uint256 nextRoundEndTime,
uint256 nextRoundPot);
event onWithdraw(address indexed withdrawAddr,
uint256 discountRevenue,
uint256 refferedRevenue,
uint256 winRevenue,
uint256 flagRevenue);
}
contract modularLong is BO3Kevents {}
contract BO3KMain is modularLong {
using SafeMath for *;
using BO3KCalcLong for uint256;
address constant public Admin = 0x3ac98F5Ea4946f58439d551E20Ed12091AF0F597;
uint256 constant public LEADER_FEE = 0.03 ether;
uint256 private adminFee = 0;
uint256 private adminRevenue = 0;
uint256 private winTeamValue = 0;
uint private winTeamID = 0;
string constant public name = "Blockchain of 3 Kindoms";
string constant public symbol = "BO3K";
uint256 constant private DISCOUNT_PROB = 200;
uint256 constant private DISCOUNT_VALUE_5PER_OFF = 50;
uint256 constant private DISCOUNT_VALUE_10PER_OFF = 100;
uint256 constant private DISCOUNT_VALUE_15PER_OFF = 150;
uint256 constant private DENOMINATOR = 1000;
uint256 constant private _nextRoundSettingTime = 1 hours;
uint256 constant private _flagBuyingInterval = 30 seconds;
uint256 constant private _maxDuration = 24 hours;
uint256 constant private _officerCommission = 150;
bool _activated = false;
bool mutex = false;
uint256 public roundID;
uint public _teamID;
BO3Kdatasets.PotSplit potSplit;
BO3Kdatasets.FlagInfo Flag;
mapping (uint256 => BO3Kdatasets.Team) team;
mapping (uint256 => mapping (uint256 => BO3Kdatasets.TeamData)) teamData;
mapping (uint256 => BO3Kdatasets.Round) round;
mapping (uint256 => mapping (address => BO3Kdatasets.Player)) player;
mapping (address => uint256) playerFlags;
constructor () public {
team[1] = BO3Kdatasets.Team(0, 500, 250, 150, 50, 50, 0, 0);
team[2] = BO3Kdatasets.Team(1, 250, 500, 150, 50, 50, 0, 0);
team[3] = BO3Kdatasets.Team(2, 375, 375, 150, 50, 50, 0, 0);
potSplit = BO3Kdatasets.PotSplit(450, 450, 50, 50);
// to-do: formation of flag and time update
Flag = BO3Kdatasets.FlagInfo(10000000000000000, now);
}
modifier isActivated() {
require (_activated == true, "Did not activated");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
// size of the code at address _addre
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Addresses not owned by human are forbidden");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 100000000000, "ground limit");
require(_eth <= 100000000000000000000000, "floor limit");
_;
}
modifier isPlayerRegistered(uint256 _roundID, address _addr) {
require (player[_roundID][_addr].hasRegistered, "The Player Has Not Registered!");
_;
}
function buyFlag(uint _tID, address refferedAddr) isActivated() isHuman() isWithinLimits(msg.value) public payable {
require(_tID == 1 ||
_tID == 2 ||
_tID == 3 ,
"Invalid Team ID!");
// core(msg.sender, msg.value, _teamID);
uint256 _now = now;
_teamID = _tID;
// if it's around the legal time
if(isLegalTime(_now)) {
// main logic of buying
buyCore(refferedAddr);
// 30 sec interval
updateTimer();
} else {
if(!isLegalTime(_now) && round[roundID].ended == false) {
round[roundID].ended = true;
endRound();
} else {
revert();
}
// to-do:rcountdown for 1 hour to cool down
}
}
function buyCore(address refferedAddr) isActivated() isWithinLimits(msg.value) private {
// flag formula
if(player[roundID][refferedAddr].isGeneral == false) {
refferedAddr = address(0);
}
address _addr = msg.sender;
uint256 _value = msg.value;
uint256 flagAmount = (round[roundID].totalEth).keysRec(_value);
require (flagAmount >= 10 ** 18, "At least 1 whole flag");
// discount info
bool getDiscount = false;
// update data of the round, contains total eth, total flags, and pot value
round[roundID].totalEth = (round[roundID].totalEth).add(_value);
round[roundID].totalFlags = (round[roundID].totalFlags).add(flagAmount);
// distribute value to the pot of the round. 50%, 25%, 37.5%, respectively
round[roundID].pot = (round[roundID].pot).add((_value.mul(team[_teamID].city)).div(DENOMINATOR));
// update data of the team, contains total eth, total flags
team[_teamID].totalEth = (team[_teamID].totalEth).add(_value);
team[_teamID].totalFlags = (team[_teamID].totalFlags).add(flagAmount);
teamData[roundID][_teamID].totalEth = (teamData[roundID][_teamID].totalEth).add(_value);
teamData[roundID][_teamID].totalFlags = (teamData[roundID][_teamID].totalFlags).add(flagAmount);
// if the user has participated in before, just add the total flag to the player
if(player[roundID][_addr].hasRegistered) {
player[roundID][_addr].flags += flagAmount;
} else {
// user data
player[roundID][_addr] = BO3Kdatasets.Player({
addr: _addr,
flags: flagAmount,
win: 0,
refferedRevenue: 0,
discountRevenue: 0,
teamID: _teamID,
generalID: 0,
payMask: 0,
hasRegistered: true,
isGeneral: false,
isWithdrawed: false
});
}
// player's flags
playerFlags[_addr] += flagAmount;
// winner ID of the round
round[roundID].playerID = _addr;
// random discount
uint256 randomValue = random();
uint256 discountValue = 0;
// discount judgement
if(randomValue < team[_teamID].grain) {
if(_value >= 10 ** 17 && _value < 10 ** 18) {
discountValue = (_value.mul(DISCOUNT_VALUE_5PER_OFF)).div(DENOMINATOR);
} else if(_value >= 10 ** 18 && _value < 10 ** 19) {
discountValue = (_value.mul(DISCOUNT_VALUE_10PER_OFF)).div(DENOMINATOR);
} else if(_value >= 10 ** 19) {
discountValue = (_value.mul(DISCOUNT_VALUE_15PER_OFF)).div(DENOMINATOR);
}
// _addr.transfer(discountValue);
// add to win bonus if getting discount
player[roundID][_addr].discountRevenue = (player[roundID][_addr].discountRevenue).add(discountValue);
getDiscount = true;
}
// distribute the eth values
// the distribution ratio differs from reffered address
uint256 soldierEarn;
// flag distribution
if(refferedAddr != address(0) && refferedAddr != _addr) {
// 25%, 50%, 37.5% for soldier, respectively
soldierEarn = (((_value.mul(team[_teamID].soldier) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags)).mul(flagAmount)/ (1000000000000000000);
// 5% for admin
adminFee += (_value.mul(team[_teamID].teamWelfare)).div(DENOMINATOR);
// 15% for officer
player[roundID][refferedAddr].refferedRevenue += (_value.mul(team[_teamID].officer)).div(DENOMINATOR);
// paymask
round[roundID].payMask += ((_value.mul(team[_teamID].soldier) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags);
player[roundID][_addr].payMask = ((((round[roundID].payMask).mul(flagAmount)) / (1000000000000000000)).sub(soldierEarn)).add(player[roundID][_addr].payMask);
} else {
// 40%, 65%, 52.5% for soldier, respectively
soldierEarn = (((_value.mul(team[_teamID].soldier + team[_teamID].officer) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags)).mul(flagAmount)/ (1000000000000000000);
// 5% for admin
adminFee += (_value.mul(team[_teamID].teamWelfare)).div(DENOMINATOR);
// paymask
round[roundID].payMask += ((_value.mul(team[_teamID].soldier + team[_teamID].officer) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags);
player[roundID][_addr].payMask = ((((round[roundID].payMask).mul(flagAmount)) / (1000000000000000000)).sub(soldierEarn)).add(player[roundID][_addr].payMask);
}
emit BO3Kevents.onDiscount(_addr,
randomValue,
discountValue,
getDiscount);
emit BO3Kevents.onBuying(_addr,
_value,
flagAmount,
playerFlags[_addr],
round[roundID].totalEth,
round[roundID].totalFlags,
round[roundID].pot);
}
function updateTimer() private {
uint256 _now = now;
uint256 newTimeInterval = (round[roundID].end).add(_flagBuyingInterval).sub(_now);
if(newTimeInterval > _maxDuration) {
newTimeInterval = _maxDuration;
}
round[roundID].end = (_now).add(newTimeInterval);
round[roundID].updatedTimeRounds = (round[roundID].updatedTimeRounds).add(1);
emit BO3Kevents.onTimeAdding(round[roundID].start,
round[roundID].end,
newTimeInterval,
(round[roundID].end).sub(_now));
}
function endRound() isActivated() private {
// end round: get winner ID, team ID, pot, and values, respectively
require (!isLegalTime(now), "The round has not finished");
address winnerPlayerID = round[roundID].playerID;
uint winnerTeamID = player[roundID][winnerPlayerID].teamID;
uint256 potValue = round[roundID].pot;
uint256 winValue = (potValue.mul(potSplit._winRatio)).div(DENOMINATOR);
uint256 soldierValue = (potValue.mul(potSplit._soldiersRatio)).div(DENOMINATOR);
uint256 nextRoundValue = (potValue.mul(potSplit._nextRatio)).div(DENOMINATOR);
uint256 adminValue = (potValue.mul(potSplit._adminRatio)).div(DENOMINATOR);
uint256 teamValue = team[winnerTeamID].totalEth;
if(winnerPlayerID == address(0x0)) {
Admin.transfer(potValue);
nextRoundValue -= nextRoundValue;
} else {
player[roundID][winnerPlayerID].win = (player[roundID][winnerPlayerID].win).add(winValue);
winTeamID = winnerTeamID;
}
// Admin.transfer(adminValue + adminFee);
adminRevenue = adminRevenue.add(adminValue).add(adminFee);
adminFee -= adminFee;
round[roundID].ended = true;
roundID++;
round[roundID].start = now.add(_nextRoundSettingTime);
round[roundID].end = (round[roundID].start).add(_maxDuration);
round[roundID].pot = nextRoundValue;
emit BO3Kevents.onRoundEnding(winnerPlayerID,
winnerTeamID,
winValue,
soldierValue,
teamValue,
round[roundID].start,
round[roundID].end,
round[roundID].pot);
}
function activate() public {
//activation
require (msg.sender == 0xABb29fd841c9B919c3B681194c6173f30Ff7055D,
"msg sender error");
require (_activated == false, "Has activated");
_activated = true;
roundID = 1;
round[roundID].start = now;
round[roundID].end = round[roundID].start + _maxDuration;
round[roundID].ended = false;
round[roundID].updatedTimeRounds = 0;
}
// next flag value
function getFlagPrice() public view returns(uint256) {
// return (((round[roundID].totalFlags).add(1000000000000000000)).ethRec(1000000000000000000));
uint256 _now = now;
if(isLegalTime(_now)) {
return (((round[roundID].totalFlags).add(1000000000000000000)).ethRec(1000000000000000000));
} else {
return (75000000000000);
}
}
function getFlagPriceByFlags (uint256 _roundID, uint256 _flagAmount) public view returns (uint256) {
return round[_roundID].totalFlags.add(_flagAmount.mul(10 ** 18)).ethRec(_flagAmount.mul(10 ** 18));
}
function getRemainTime() isActivated() public view returns(uint256) {
return ((round[roundID].start).sub(now));
}
function isLegalTime(uint256 _now) internal view returns(bool) {
return (_now >= round[roundID].start && _now <= round[roundID].end);
}
function isLegalTime() public view returns(bool) {
uint256 _now = now;
return (_now >= round[roundID].start && _now <= round[roundID].end);
}
function random() internal view returns(uint256) {
return uint256(uint256(keccak256(block.timestamp, block.difficulty)) % DENOMINATOR);
}
function withdraw(uint256 _roundID) isActivated() isHuman() public {
require (player[_roundID][msg.sender].hasRegistered == true, "Not Registered Before");
uint256 _discountRevenue = player[_roundID][msg.sender].discountRevenue;
uint256 _refferedRevenue = player[_roundID][msg.sender].refferedRevenue;
uint256 _winRevenue = player[_roundID][msg.sender].win;
uint256 _flagRevenue = getFlagRevenue(_roundID) ;
if(isLegalTime(now) && !round[_roundID].ended) {
// to-do: withdraw function
msg.sender.transfer(_discountRevenue + _refferedRevenue + _winRevenue + _flagRevenue);
} else {
msg.sender.transfer(getTeamBonus(_roundID) + _discountRevenue + _refferedRevenue + _winRevenue + _flagRevenue);
}
player[_roundID][msg.sender].discountRevenue = 0;
player[_roundID][msg.sender].refferedRevenue = 0;
player[_roundID][msg.sender].win = 0;
player[_roundID][msg.sender].payMask = _flagRevenue.add(player[_roundID][msg.sender].payMask);
// if(round[_roundID].ended) {
// player[_roundID][msg.sender].flags = 0;
// }
player[_roundID][msg.sender].isWithdrawed = true;
emit BO3Kevents.onWithdraw(msg.sender,
_discountRevenue,
_refferedRevenue,
_winRevenue,
_flagRevenue);
}
function becomeGeneral(uint _generalID) public payable {
require(msg.value >= LEADER_FEE && player[roundID][msg.sender].hasRegistered, "Not enough money or not player");
msg.sender.transfer(LEADER_FEE);
player[roundID][msg.sender].isGeneral = true;
player[roundID][msg.sender].generalID = _generalID;
}
function getIsActive () public view returns (bool) {
return _activated;
}
function getPot (uint256 _roundID) public view returns (uint256) {
return round[_roundID].pot;
}
function getTime (uint256 _roundID) public view returns (uint256, uint256) {
if(isLegalTime(now)) {
return (round[_roundID].start, (round[_roundID].end).sub(now));
} else {
return (0, 0);
}
}
function getTeam (uint256 _roundID) public view returns (uint) {
return player[_roundID][msg.sender].teamID;
}
function getTeamData (uint256 _roundID, uint _tID) public view returns (uint256, uint256) {
return (teamData[_roundID][_tID].totalFlags, teamData[_roundID][_tID].totalEth);
}
function getTeamBonus (uint256 _roundID) public view returns (uint256) {
// pot * 0.45 * (playerflag/teamflag)
uint256 potValue = round[_roundID].pot;
uint256 _winValue = (potValue.mul(potSplit._soldiersRatio)).div(DENOMINATOR);
uint _tID = player[_roundID][msg.sender].teamID;
if(isLegalTime(now) && (_roundID == roundID)) {
// return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(team[_tID].totalFlags);
return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(teamData[_roundID][_tID].totalFlags);
} else {
if(_tID != winTeamID) {
return 0;
} else if (player[_roundID][msg.sender].isWithdrawed) {
return 0;
} else {
// return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(team[_tID].totalFlags);
return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(teamData[_roundID][_tID].totalFlags);
}
}
}
function getBonus (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win;
}
function getAllRevenue (uint256 _roundID) public view returns (uint256) {
return (getTeamBonus(_roundID) + player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
}
function getAllWithdrawableRevenue (uint256 _roundID) public view returns (uint256) {
if(isLegalTime(now) && (_roundID == roundID))
return (player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
return (getTeamBonus(_roundID) + player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
}
function getFlagRevenue(uint _round) public view returns(uint256)
{
return((((player[_round][msg.sender].flags).mul(round[_round].payMask)) / (1000000000000000000)).sub(player[_round][msg.sender].payMask));
}
function getGeneralProfit (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].refferedRevenue;
}
function getDistributedETH (uint256 _roundID) public view returns (uint256) {
return (round[_roundID].totalEth).sub(round[_roundID].pot).sub(adminFee);
}
function getGeneral (uint256 _roundID) public view returns (bool, uint) {
return (player[_roundID][msg.sender].isGeneral, player[_roundID][msg.sender].generalID);
}
function getPlayerFlagAmount (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].flags;
}
function getTotalFlagAmount (uint256 _roundID) public view returns (uint256) {
return round[_roundID].totalFlags;
}
function getTotalEth (uint256 _roundID) public view returns (uint256) {
return round[_roundID].totalEth;
}
function getUpdatedTime (uint256 _roundID) public view returns (uint) {
return round[_roundID].updatedTimeRounds;
}
function getRoundData(uint256 _roundID) public view returns(address, uint256, uint256, bool) {
return (round[_roundID].playerID, round[_roundID].pot, round[_roundID].totalEth, round[_roundID].ended);
}
function getAdminRevenue () public view returns (uint) {
return adminRevenue;
}
function withdrawAdminRevenue() public {
require (msg.sender == Admin);
Admin.transfer(adminRevenue);
adminRevenue = 0;
}
}
library BO3KCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256){
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) {
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth) internal pure returns(uint256) {
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys) internal pure returns(uint256) {
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
library BO3Kdatasets {
struct Team {
uint teamID;
uint256 city;
uint256 soldier;
uint256 officer;
uint256 grain;
uint256 teamWelfare;
uint256 totalEth;
uint256 totalFlags;
}
struct TeamData {
uint256 totalEth;
uint256 totalFlags;
}
struct PotSplit {
uint256 _winRatio;
uint256 _soldiersRatio;
uint256 _nextRatio;
uint256 _adminRatio;
}
struct Round {
address playerID; // pID of player in lead
// uint256 teamID; // tID of team in lead
uint256 start; // time round started
uint256 end; // time ends/ended
uint256 totalFlags; // keys
uint256 totalEth; // total eth in
uint256 pot; // eth to pot (during round) / final amount paid to winner (after round ends)
uint256 payMask;
uint updatedTimeRounds;
bool ended; // has round end function been ran
}
struct Player {
address addr; // player
uint256 flags; // flags
uint256 win; // winnings vault
uint256 refferedRevenue;
uint256 discountRevenue;
uint256 payMask;
uint teamID;
bool hasRegistered;
bool isGeneral;
uint generalID;
bool isWithdrawed;
}
struct FlagInfo {
uint256 _flagValue;
uint256 updateTime;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
require(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y) {
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x) internal pure returns (uint256) {
return (mul(x,x));
}
function pwr(uint256 x, uint256 y) internal pure returns (uint256) {
if (x==0)
return (0);
else if (y==0)
return (1);
else {
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
| 217,124 | 12,982 |
baa8ba65888520cd5a019abfb984db1945553a7f2668f1d6b41e389ca08da3a7
| 17,515 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/4a/4a1adac56dac19b829b5a9dcb09ababccabf27ee_VaultFactory.sol
| 3,898 | 14,153 |
// SPDX-License-Identifier: UNLICENSE
pragma solidity 0.8.10;
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC20.sol)
abstract contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
string public name;
string public symbol;
uint8 public immutable decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
constructor(string memory _name,
string memory _symbol,
uint8 _decimals) {
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
balanceOf[msg.sender] -= amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual returns (bool) {
uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
balanceOf[from] -= amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(from, to, amount);
return true;
}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual {
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
// Unchecked because the only math done is incrementing
// the owner's nonce which cannot realistically overflow.
unchecked {
address recoveredAddress = ecrecover(keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(abi.encode(keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"),
owner,
spender,
value,
nonces[owner]++,
deadline)))),
v,
r,
s);
require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
allowance[recoveredAddress][spender] = value;
}
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)));
}
function _mint(address to, uint256 amount) internal virtual {
totalSupply += amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
balanceOf[from] -= amount;
// Cannot underflow because a user's balance
// will never be larger than the total supply.
unchecked {
totalSupply -= amount;
}
emit Transfer(from, address(0), amount);
}
}
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/auth/Auth.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
abstract contract Auth {
event OwnerUpdated(address indexed user, address indexed newOwner);
event AuthorityUpdated(address indexed user, Authority indexed newAuthority);
address public owner;
Authority public authority;
constructor(address _owner, Authority _authority) {
owner = _owner;
authority = _authority;
emit OwnerUpdated(msg.sender, _owner);
emit AuthorityUpdated(msg.sender, _authority);
}
modifier requiresAuth() {
require(isAuthorized(msg.sender, msg.sig), "UNAUTHORIZED");
_;
}
function isAuthorized(address user, bytes4 functionSig) internal view virtual returns (bool) {
Authority auth = authority; // Memoizing authority saves us a warm SLOAD, around 100 gas.
return (address(auth) != address(0) && auth.canCall(user, address(this), functionSig)) || user == owner;
}
function setAuthority(Authority newAuthority) public virtual {
// We check if the caller is the owner first because we want to ensure they can
// always swap out the authority even if it's reverting or using up a lot of gas.
require(msg.sender == owner || authority.canCall(msg.sender, address(this), msg.sig));
authority = newAuthority;
emit AuthorityUpdated(msg.sender, newAuthority);
}
function setOwner(address newOwner) public virtual requiresAuth {
owner = newOwner;
emit OwnerUpdated(msg.sender, newOwner);
}
}
/// @notice A generic interface for a contract which provides authorization data to an Auth instance.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/auth/Auth.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
interface Authority {
function canCall(address user,
address target,
bytes4 functionSig) external view returns (bool);
}
/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
uint256 private locked = 1;
modifier nonReentrant() {
require(locked == 1, "REENTRANCY");
locked = 2;
_;
locked = 1;
}
}
interface IERC20 {
function balanceOf(address) external returns (uint256);
function transfer(address to, uint256 amount) external;
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
contract VaultFactory is Auth(msg.sender, Authority(address(0))), ReentrancyGuard {
event CreateVault(address indexed token);
event Deposit(address indexed from, uint16 vaultId, uint256 amount, uint256 depositFee);
event Withdraw(address indexed from, uint16 vaultId, uint256 amount);
event Claim(address indexed from, uint16 vaultId, uint256 amount, uint256 claimFee);
address public feeAddress; // fee wallet (for claims)
/// @notice Info of each user that stakes LP tokens.
struct UserInfo {
uint256 depositBalance; // balance the user has staked in the vault
uint256 lastClaimTime; // timestamp of last payout
}
/// @notice Map of each address that deposited tokens.
mapping(uint16 => mapping(address => UserInfo)) public userInfo;
/// @notice contains deposit and treasury amounts for each user
struct VaultInfo {
IERC20 depositedToken; // address of deposit token
uint16 depositFeeBP; // deposit fee (goes to treasury) in basis points
uint16 claimFeeBP; // claim fee (goes to devWallet) in basis points
uint16 treasuryRewardBP; // reward percent accumulated after one period, divided amongst stakers (suggested ~20%)
uint256 treasuryBalance; // treasury for paying rewards out
uint256 depositBalance; // total user deposits (using balanceOf would be a security issue)
}
VaultInfo[] public vaultInfo; // this is an array so we can iterate (without danger of a large iteration)
constructor(address _feeAddress) {
feeAddress = _feeAddress;
}
/// create a new vault for a token
function createVault(IERC20 _token,
uint16 _depositFeeBP,
uint16 _claimFeeBP,
uint16 _treasuryRewardBP) public requiresAuth {
require(_depositFeeBP < 10000 && _depositFeeBP > 0,
"deposit fee must be between 0% and 100%");
require(_treasuryRewardBP <= 10000 && _treasuryRewardBP >= 0,
"reward fee must be between 0% and 100%");
vaultInfo.push(VaultInfo({
depositedToken: IERC20(_token),
depositFeeBP: _depositFeeBP,
claimFeeBP: _claimFeeBP,
treasuryRewardBP: _treasuryRewardBP,
treasuryBalance: 0,
depositBalance: 0
}));
emit CreateVault(address(_token));
}
function deposit(uint16 _vaultId, uint256 _amount) public nonReentrant {
require(_amount > 0, "cannot deposit 0 funds");
require(_vaultId < vaultInfo.length, "no such vault");
VaultInfo storage vault = vaultInfo[_vaultId];
UserInfo storage user = userInfo[_vaultId][msg.sender];
// if the user has deposited already, claim any outstanding rewards
if(user.depositBalance > 0) {
claim(_vaultId);
}
// deposit token (minus fee) into vault
vault.depositedToken.transferFrom(address(msg.sender),
address(this),
_amount);
// calculate deposit fee (* 10000 to deal with basis points)
uint256 depositFee = (_amount * vault.depositFeeBP) / 10000;
user.lastClaimTime = block.timestamp;
// place the deposit fee into the treasury
vault.treasuryBalance += depositFee;
uint256 depositBalance = _amount - depositFee;
// subtract fee from users deposit amount
user.depositBalance += depositBalance;
vault.depositBalance += depositBalance;
emit Deposit(address(msg.sender), _vaultId, depositBalance, depositFee);
}
/// calculates the users share of a vault as a percentage BP
function userVaultShareBP(uint16 _vaultId, address _address) public view returns (uint256) {
require(_vaultId < vaultInfo.length, "no such vault");
VaultInfo storage vault = vaultInfo[_vaultId];
UserInfo storage user = userInfo[_vaultId][_address];
if (user.depositBalance == 0) {
return 0;
}
return (user.depositBalance * 10000) / vault.depositBalance;
}
/// returns vault reward pending for a user
function pendingReward(uint16 _vaultId, address _address) public view returns (uint256) {
require(_vaultId < vaultInfo.length, "no such vault");
VaultInfo memory vault = vaultInfo[_vaultId];
if (vault.treasuryBalance == 0) {
return 0;
}
uint256 maxVaultPayout = (vault.treasuryBalance * vault.treasuryRewardBP) / 10000;
if (maxVaultPayout == 0) {
return 0;
}
uint256 maxUserPayout = (maxVaultPayout * userVaultShareBP(_vaultId, _address)) / 10000;
UserInfo memory user = userInfo[_vaultId][_address];
if(block.timestamp > user.lastClaimTime + 24 hours) {
// 24 hours have passed since last claim, show max claim
return maxUserPayout;
}
uint256 deltaSinceClaim = block.timestamp - user.lastClaimTime;
return maxUserPayout * deltaSinceClaim / 24 hours;
}
function withdraw(uint16 _vaultId, uint256 _amount) public nonReentrant {
require(_amount > 0, "cannot withdraw 0 funds");
require(_vaultId < vaultInfo.length, "no such vault");
VaultInfo storage vault = vaultInfo[_vaultId];
UserInfo storage user = userInfo[_vaultId][msg.sender];
require(_amount <= user.depositBalance, "attempt to overdraw funds");
user.depositBalance -= _amount;
vault.depositBalance -= _amount;
vault.depositedToken.transfer(address(msg.sender), _amount);
emit Withdraw(address(msg.sender), _vaultId, _amount);
}
function claim(uint16 _vaultId) public nonReentrant returns (uint256) {
require(_vaultId < vaultInfo.length, "no such vault");
VaultInfo storage vault = vaultInfo[_vaultId];
UserInfo storage user = userInfo[_vaultId][msg.sender];
// // user cannot claim until 24 hours has passed
// require(// user.lastClaimTime <= (block.timestamp - 1 days),
// "no rewards to claim yet"
//);
// uint256 rewardDebt = user.rewardDebt;
uint256 rewardDebt = pendingReward(_vaultId, address(msg.sender));
if (rewardDebt == 0) {
return 0;
}
// take the debt from the treasury
vault.treasuryBalance -= rewardDebt;
// collect a claim fee if there is one.
if (vault.claimFeeBP > 0) {
// calculate fee (* 10000 to deal with basis points)
uint256 claimFee = (rewardDebt * vault.claimFeeBP) / 10000;
// transfer the fee to the feeAddress
vault.depositedToken.transfer(address(feeAddress),
claimFee);
// remove the fee from the amount owed to user
rewardDebt -= claimFee;
emit Claim(address(msg.sender), _vaultId, rewardDebt, claimFee);
} else {
emit Claim(address(msg.sender), _vaultId, rewardDebt, 0);
}
user.lastClaimTime = block.timestamp;
vault.depositedToken.transfer(address(msg.sender),
rewardDebt);
return rewardDebt;
}
/// EMERGENCY ONLY!!! - abandons pending rewards!!!
function emergencyWithdraw(uint16 _vaultId) public nonReentrant {
require(_vaultId < vaultInfo.length, "no such vault");
VaultInfo storage vault = vaultInfo[_vaultId];
UserInfo storage user = userInfo[_vaultId][msg.sender];
uint256 userBalance = user.depositBalance;
user.depositBalance = 0;
vault.depositBalance -= userBalance;
vault.depositedToken.transfer(address(msg.sender), userBalance);
}
}
| 124,755 | 12,983 |
7aee906853a1b34e179523607777fca7ba400c5ddacb69d7025ef05a6a0f3095
| 18,018 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/45/454a1c73d39e1c69f7a51be808cd85e5237a5b3c_Pot.sol
| 3,097 | 11,514 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
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);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
library myLibrary {
struct bidPrice {
uint256 bidOption;
uint256 variable1;
uint256 variable2;
}
struct expiryTimeInfo {
uint256 expiryOption;
uint256 startTime;
uint256 decreaseBy;
uint256 minimumTime;
}
struct createPotValue {
address topOwner;
address ownerOfTournament;
address potToken;
uint256 potAmount;
address bidToken;
bidPrice bid;
address[] toAddress;
uint256[] toPercent;
expiryTimeInfo expiryTime;
bool priorityPool;
uint256 toPotFee;
uint256 toPreviousFee;
}
}
contract Pot {
using SafeMath for uint256;
address public potToken;
uint256 public potAmount = 0;
address public bidToken;
uint256 public bidAmount;
bool public priorityPool;
bool public isClaim;
uint256 public createdDate;
uint256 public timeUntilExpiry;
address public ownerOfTournament;
address public lastBidWinner;
uint256 public lengthOfBidDistribution = 0;
uint256 public toOwnerFee = 3;
uint256 public percent = 100;
uint256 public toPotFee;
address public toPreviousBidder;
uint256 public toPreviousBidderFee;
uint256 private winnerClaimAllowTime = 600; // 2851200000; // 33 days
uint256 private createClaimAllowTime = 720; // 5702400000; // 66 days
address public topOwner;
uint256 public bidOption;
uint256 public bidVariable1;
uint256 public bidVariable2;
uint256 public claimedDate;
uint256 public expirationTime;
uint256 public expExpiryOption;
uint256 public expDecreaseBy;
uint256 public expMinimumTime;
IERC20 public token;
struct bidDistributionInfo {
address toAddress;
uint256 percentage;
}
mapping(uint256 => bidDistributionInfo) public bidInfo;
modifier onlyOwner() {
require(msg.sender == ownerOfTournament, "Not onwer");
_;
}
function setTopOwner(address newTopOwner) public {
require(topOwner == msg.sender, "Error: you can not change Top Owner address!");
topOwner = newTopOwner;
}
function calcBidAmount(uint256 _bidOption, uint256 _variable1, uint256 _variable2) internal {
if(_bidOption == 1) {
bidAmount = _variable1;
} else if (_bidOption == 2) {
bidAmount = potAmount.mul(_variable1).div(percent);
} else if (_bidOption == 3) {
bidAmount = bidAmount + bidAmount.mul(_variable2).div(percent);
}
}
function initialize(myLibrary.createPotValue memory sValue) external {
if (lengthOfBidDistribution > 0) {
require(topOwner == msg.sender, "Error: you can not change initial variable");
}
potToken = sValue.potToken;
bidToken = sValue.bidToken;
IERC20 _token = IERC20(address(potToken));
token = _token;
lengthOfBidDistribution = sValue.toAddress.length;
for(uint256 i = 0; i < sValue.toAddress.length; i++) {
bidInfo[i].toAddress = sValue.toAddress[i];
bidInfo[i].percentage = sValue.toPercent[i];
}
priorityPool = sValue.priorityPool;
createdDate = block.timestamp;
timeUntilExpiry = createdDate + sValue.expiryTime.startTime;
expExpiryOption = sValue.expiryTime.expiryOption;
expirationTime = sValue.expiryTime.startTime;
expDecreaseBy = sValue.expiryTime.decreaseBy;
expMinimumTime = sValue.expiryTime.minimumTime;
potAmount += sValue.potAmount;
lastBidWinner = sValue.ownerOfTournament;
toPreviousBidderFee = sValue.toPreviousFee;
ownerOfTournament = sValue.ownerOfTournament;
topOwner = sValue.topOwner;
toPotFee = sValue.toPotFee;
bidOption = sValue.bid.bidOption;
bidVariable1 = sValue.bid.variable1;
bidVariable2 = sValue.bid.variable2;
isClaim = false;
if(bidOption == 1) {
bidAmount = bidVariable1;
} else if (bidOption == 2) {
bidAmount = potAmount.mul(bidVariable1).div(percent);
} else if (bidOption == 3) {
bidAmount = bidVariable1;
}
}
function bid() public payable returns (uint256) {
require(timeUntilExpiry > block.timestamp, "You cannot bid! Because this pot is closed biding!");
require(msg.value > 0, "Insufficinet value");
require(msg.value == bidAmount, "Your bid amount will not exact!");
toPreviousBidder = lastBidWinner;
uint256 value = msg.value;
lastBidWinner = msg.sender;
if(expExpiryOption == 2 && expirationTime > expMinimumTime) {
expirationTime -= expDecreaseBy;
}
uint256 onwerFee = bidAmount.mul(toOwnerFee).div(percent);
payable(address(topOwner)).transfer(onwerFee);
value = value - onwerFee;
uint256 previousBidderFee = bidAmount.mul(toPreviousBidderFee).div(percent);
payable(address(toPreviousBidder)).transfer(previousBidderFee);
value = value - previousBidderFee;
for (uint i = 0; i < lengthOfBidDistribution; i++) {
uint256 bidFee = bidAmount.mul(bidInfo[i].percentage).div(percent);
payable(address(bidInfo[i].toAddress)).transfer(bidFee);
value = value - bidFee;
}
uint256 createdBid = block.timestamp;
timeUntilExpiry = createdBid + expirationTime;
potAmount = address(this).balance;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
return bidAmount;
}
function getLifeTime() public view returns (uint256) {
if(timeUntilExpiry > block.timestamp){
uint256 lifeTime = timeUntilExpiry - block.timestamp;
return lifeTime;
} else {
return 0;
}
}
function claim() public returns (uint256) {
address claimAvailableAddress;
if(block.timestamp < timeUntilExpiry) {
claimAvailableAddress = 0x0000000000000000000000000000000000000000;
} else if (timeUntilExpiry < block.timestamp && block.timestamp < timeUntilExpiry + winnerClaimAllowTime) {
claimAvailableAddress = lastBidWinner;
} else if (timeUntilExpiry + winnerClaimAllowTime < block.timestamp && block.timestamp < timeUntilExpiry + createClaimAllowTime) {
claimAvailableAddress = ownerOfTournament;
} else {
claimAvailableAddress = topOwner;
}
require(msg.sender == claimAvailableAddress, "You cannot claim!");
payable(address(msg.sender)).transfer(address(this).balance);
isClaim = true;
claimedDate = block.timestamp;
return address(this).balance;
}
modifier checkAllowance(uint256 amount) {
require(token.allowance(msg.sender, address(this)) >= amount, "Allowance Error");
_;
}
function depositToken() external payable {
require(msg.value > 0, "you can deposit more than 0!");
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
uint256 balance = address(msg.sender).balance;
potAmount = msg.value;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
require(balance >= msg.value, "Insufficient balance or allowance");
}
function depositERC20Token(uint256 _amount) external payable checkAllowance(_amount) {
require(msg.value > 0, "you can deposit more than 0!");
require(msg.sender == ownerOfTournament, "You cannot deposit because you are not owner of this tournament");
require(_amount > 0, "Insufficinet value");
token.transfer(address(this), _amount);
uint256 balance = address(msg.sender).balance;
potAmount = _amount;
calcBidAmount(bidOption, bidVariable1, bidVariable2);
require(balance >= msg.value, "Insufficient balance or allowance");
}
function depositERC20(uint256 _amount) external {
// require(_amount > 0, "Insufficinet value");
token.transfer(address(this), _amount);
// potAmount = _amount;
// calcBidAmount(bidOption, bidVariable1, bidVariable2);
}
}
| 111,465 | 12,984 |
f3486c37a620cb5029d2730c2a87eb5220ca579e1d56f6e5ce327e598b7f205a
| 19,972 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7c/7c4c3c1e7353e0ad1351e8af20c8595114c4d47a_Bribe.sol
| 4,459 | 18,589 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
library Math {
function max(uint a, uint b) internal pure returns (uint) {
return a >= b ? a : b;
}
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
}
interface erc20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint amount) external returns (bool);
function balanceOf(address) external view returns (uint);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
}
interface ve {
function isApprovedOrOwner(address, uint) external view returns (bool);
function ownerOf(uint) external view returns (address);
}
interface IBaseV1Voter {
function _ve() external view returns (address);
}
contract Bribe {
address public immutable factory; // only factory can modify balances (since it only happens on vote())
address public immutable _ve;
uint public constant DURATION = 7 days; // rewards are released over 7 days
uint public constant PRECISION = 10 ** 18;
// default snx staking contract implementation
mapping(address => uint) public rewardRate;
mapping(address => uint) public periodFinish;
mapping(address => uint) public lastUpdateTime;
mapping(address => uint) public rewardPerTokenStored;
mapping(address => mapping(uint => uint)) public lastEarn;
mapping(address => mapping(uint => uint)) public userRewardPerTokenStored;
address[] public rewards;
mapping(address => bool) public isReward;
uint public totalSupply;
mapping(uint => uint) public balanceOf;
/// @notice A checkpoint for marking balance
struct Checkpoint {
uint timestamp;
uint balanceOf;
}
/// @notice A checkpoint for marking reward rate
struct RewardPerTokenCheckpoint {
uint timestamp;
uint rewardPerToken;
}
/// @notice A checkpoint for marking supply
struct SupplyCheckpoint {
uint timestamp;
uint supply;
}
/// @notice A record of balance checkpoints for each account, by index
mapping (uint => mapping (uint => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (uint => uint) public numCheckpoints;
/// @notice A record of balance checkpoints for each token, by index
mapping (uint => SupplyCheckpoint) public supplyCheckpoints;
/// @notice The number of checkpoints
uint public supplyNumCheckpoints;
/// @notice A record of balance checkpoints for each token, by index
mapping (address => mapping (uint => RewardPerTokenCheckpoint)) public rewardPerTokenCheckpoints;
/// @notice The number of checkpoints for each token
mapping (address => uint) public rewardPerTokenNumCheckpoints;
event Deposit(address indexed from, uint tokenId, uint amount);
event Withdraw(address indexed from, uint tokenId, uint amount);
event NotifyReward(address indexed from, address indexed reward, uint amount);
event ClaimRewards(address indexed from, address indexed reward, uint amount);
constructor(address _factory) {
factory = _factory;
_ve = IBaseV1Voter(_factory)._ve();
}
// simple re-entrancy check
uint internal _unlocked = 1;
modifier lock() {
require(_unlocked == 1, 'lock');
_unlocked = 2;
_;
_unlocked = 1;
}
function getPriorBalanceIndex(uint tokenId, uint timestamp) public view returns (uint) {
uint nCheckpoints = numCheckpoints[tokenId];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[tokenId][nCheckpoints - 1].timestamp <= timestamp) {
return (nCheckpoints - 1);
}
// Next check implicit zero balance
if (checkpoints[tokenId][0].timestamp > timestamp) {
return 0;
}
uint lower = 0;
uint upper = nCheckpoints - 1;
while (upper > lower) {
uint center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[tokenId][center];
if (cp.timestamp == timestamp) {
return center;
} else if (cp.timestamp < timestamp) {
lower = center;
} else {
upper = center - 1;
}
}
return lower;
}
function getPriorSupplyIndex(uint timestamp) public view returns (uint) {
uint nCheckpoints = supplyNumCheckpoints;
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (supplyCheckpoints[nCheckpoints - 1].timestamp <= timestamp) {
return (nCheckpoints - 1);
}
// Next check implicit zero balance
if (supplyCheckpoints[0].timestamp > timestamp) {
return 0;
}
uint lower = 0;
uint upper = nCheckpoints - 1;
while (upper > lower) {
uint center = upper - (upper - lower) / 2; // ceil, avoiding overflow
SupplyCheckpoint memory cp = supplyCheckpoints[center];
if (cp.timestamp == timestamp) {
return center;
} else if (cp.timestamp < timestamp) {
lower = center;
} else {
upper = center - 1;
}
}
return lower;
}
function getPriorRewardPerToken(address token, uint timestamp) public view returns (uint, uint) {
uint nCheckpoints = rewardPerTokenNumCheckpoints[token];
if (nCheckpoints == 0) {
return (0,0);
}
// First check most recent balance
if (rewardPerTokenCheckpoints[token][nCheckpoints - 1].timestamp <= timestamp) {
return (rewardPerTokenCheckpoints[token][nCheckpoints - 1].rewardPerToken, rewardPerTokenCheckpoints[token][nCheckpoints - 1].timestamp);
}
// Next check implicit zero balance
if (rewardPerTokenCheckpoints[token][0].timestamp > timestamp) {
return (0,0);
}
uint lower = 0;
uint upper = nCheckpoints - 1;
while (upper > lower) {
uint center = upper - (upper - lower) / 2; // ceil, avoiding overflow
RewardPerTokenCheckpoint memory cp = rewardPerTokenCheckpoints[token][center];
if (cp.timestamp == timestamp) {
return (cp.rewardPerToken, cp.timestamp);
} else if (cp.timestamp < timestamp) {
lower = center;
} else {
upper = center - 1;
}
}
return (rewardPerTokenCheckpoints[token][lower].rewardPerToken, rewardPerTokenCheckpoints[token][lower].timestamp);
}
function _writeCheckpoint(uint tokenId, uint balance) internal {
uint _timestamp = block.timestamp;
uint _nCheckPoints = numCheckpoints[tokenId];
if (_nCheckPoints > 0 && checkpoints[tokenId][_nCheckPoints - 1].timestamp == _timestamp) {
checkpoints[tokenId][_nCheckPoints - 1].balanceOf = balance;
} else {
checkpoints[tokenId][_nCheckPoints] = Checkpoint(_timestamp, balance);
numCheckpoints[tokenId] = _nCheckPoints + 1;
}
}
function _writeRewardPerTokenCheckpoint(address token, uint reward, uint timestamp) internal {
uint _nCheckPoints = rewardPerTokenNumCheckpoints[token];
if (_nCheckPoints > 0 && rewardPerTokenCheckpoints[token][_nCheckPoints - 1].timestamp == timestamp) {
rewardPerTokenCheckpoints[token][_nCheckPoints - 1].rewardPerToken = reward;
} else {
rewardPerTokenCheckpoints[token][_nCheckPoints] = RewardPerTokenCheckpoint(timestamp, reward);
rewardPerTokenNumCheckpoints[token] = _nCheckPoints + 1;
}
}
function _writeSupplyCheckpoint() internal {
uint _nCheckPoints = supplyNumCheckpoints;
uint _timestamp = block.timestamp;
if (_nCheckPoints > 0 && supplyCheckpoints[_nCheckPoints - 1].timestamp == _timestamp) {
supplyCheckpoints[_nCheckPoints - 1].supply = totalSupply;
} else {
supplyCheckpoints[_nCheckPoints] = SupplyCheckpoint(_timestamp, totalSupply);
supplyNumCheckpoints = _nCheckPoints + 1;
}
}
function rewardsListLength() external view returns (uint) {
return rewards.length;
}
// returns the last time the reward was modified or periodFinish if the reward has ended
function lastTimeRewardApplicable(address token) public view returns (uint) {
return Math.min(block.timestamp, periodFinish[token]);
}
// allows a user to claim rewards for a given token
function getReward(uint tokenId, address[] memory tokens) external lock {
require(ve(_ve).isApprovedOrOwner(msg.sender, tokenId), 'not approve or owner');
for (uint i = 0; i < tokens.length; i++) {
(rewardPerTokenStored[tokens[i]], lastUpdateTime[tokens[i]]) = _updateRewardPerToken(tokens[i]);
uint _reward = earned(tokens[i], tokenId);
lastEarn[tokens[i]][tokenId] = block.timestamp;
userRewardPerTokenStored[tokens[i]][tokenId] = rewardPerTokenStored[tokens[i]];
if (_reward > 0) _safeTransfer(tokens[i], msg.sender, _reward);
emit ClaimRewards(msg.sender, tokens[i], _reward);
}
_writeCheckpoint(tokenId, balanceOf[tokenId]);
_writeSupplyCheckpoint();
}
// used by BaseV1Voter to allow batched reward claims
function getRewardForOwner(uint tokenId, address[] memory tokens) external lock {
require(msg.sender == factory, '!factory');
address _owner = ve(_ve).ownerOf(tokenId);
for (uint i = 0; i < tokens.length; i++) {
(rewardPerTokenStored[tokens[i]], lastUpdateTime[tokens[i]]) = _updateRewardPerToken(tokens[i]);
uint _reward = earned(tokens[i], tokenId);
lastEarn[tokens[i]][tokenId] = block.timestamp;
userRewardPerTokenStored[tokens[i]][tokenId] = rewardPerTokenStored[tokens[i]];
if (_reward > 0) _safeTransfer(tokens[i], _owner, _reward);
emit ClaimRewards(_owner, tokens[i], _reward);
}
_writeCheckpoint(tokenId, balanceOf[tokenId]);
_writeSupplyCheckpoint();
}
function rewardPerToken(address token) public view returns (uint) {
if (totalSupply == 0) {
return rewardPerTokenStored[token];
}
return rewardPerTokenStored[token] + ((lastTimeRewardApplicable(token) - Math.min(lastUpdateTime[token], periodFinish[token])) * rewardRate[token] * PRECISION / totalSupply);
}
function batchRewardPerToken(address token, uint maxRuns) external {
(rewardPerTokenStored[token], lastUpdateTime[token]) = _batchRewardPerToken(token, maxRuns);
}
function _batchRewardPerToken(address token, uint maxRuns) internal returns (uint, uint) {
uint _startTimestamp = lastUpdateTime[token];
uint reward = rewardPerTokenStored[token];
if (supplyNumCheckpoints == 0) {
return (reward, block.timestamp);
}
if (rewardRate[token] == 0) {
return (reward, block.timestamp);
}
uint _startIndex = getPriorSupplyIndex(_startTimestamp);
uint _endIndex = Math.min(supplyNumCheckpoints-1, maxRuns);
for (uint i = _startIndex; i < _endIndex; i++) {
SupplyCheckpoint memory sp0 = supplyCheckpoints[i];
if (sp0.supply > 0) {
SupplyCheckpoint memory sp1 = supplyCheckpoints[i+1];
(uint _reward, uint endTime) = _calcRewardPerToken(token, sp1.timestamp, sp0.timestamp, sp0.supply, _startTimestamp);
reward += _reward;
_writeRewardPerTokenCheckpoint(token, reward, endTime);
_startTimestamp = endTime;
}
}
return (reward, _startTimestamp);
}
function _calcRewardPerToken(address token, uint timestamp1, uint timestamp0, uint supply, uint startTimestamp) internal view returns (uint, uint) {
uint endTime = Math.max(timestamp1, startTimestamp);
return (((Math.min(endTime, periodFinish[token]) - Math.min(Math.max(timestamp0, startTimestamp), periodFinish[token])) * rewardRate[token] * PRECISION / supply), endTime);
}
function _updateRewardPerToken(address token) internal returns (uint, uint) {
uint _startTimestamp = lastUpdateTime[token];
uint reward = rewardPerTokenStored[token];
if (supplyNumCheckpoints == 0) {
return (reward, block.timestamp);
}
if (rewardRate[token] == 0) {
return (reward, block.timestamp);
}
uint _startIndex = getPriorSupplyIndex(_startTimestamp);
uint _endIndex = supplyNumCheckpoints-1;
if (_endIndex - _startIndex > 1) {
for (uint i = _startIndex; i < _endIndex; i++) {
SupplyCheckpoint memory sp0 = supplyCheckpoints[i];
if (sp0.supply > 0) {
SupplyCheckpoint memory sp1 = supplyCheckpoints[i+1];
(uint _reward, uint _endTime) = _calcRewardPerToken(token, sp1.timestamp, sp0.timestamp, sp0.supply, _startTimestamp);
reward += _reward;
_writeRewardPerTokenCheckpoint(token, reward, _endTime);
_startTimestamp = _endTime;
}
}
}
SupplyCheckpoint memory sp = supplyCheckpoints[_endIndex];
if (sp.supply > 0) {
(uint _reward,) = _calcRewardPerToken(token, lastTimeRewardApplicable(token), Math.max(sp.timestamp, _startTimestamp), sp.supply, _startTimestamp);
reward += _reward;
_writeRewardPerTokenCheckpoint(token, reward, block.timestamp);
_startTimestamp = block.timestamp;
}
return (reward, _startTimestamp);
}
function earned(address token, uint tokenId) public view returns (uint) {
uint _startTimestamp = Math.max(lastEarn[token][tokenId], rewardPerTokenCheckpoints[token][0].timestamp);
if (numCheckpoints[tokenId] == 0) {
return 0;
}
uint _startIndex = getPriorBalanceIndex(tokenId, _startTimestamp);
uint _endIndex = numCheckpoints[tokenId]-1;
uint reward = 0;
if (_endIndex - _startIndex > 1) {
for (uint i = _startIndex; i < _endIndex; i++) {
Checkpoint memory cp0 = checkpoints[tokenId][i];
Checkpoint memory cp1 = checkpoints[tokenId][i+1];
(uint _rewardPerTokenStored0,) = getPriorRewardPerToken(token, cp0.timestamp);
(uint _rewardPerTokenStored1,) = getPriorRewardPerToken(token, cp1.timestamp);
reward += cp0.balanceOf * (_rewardPerTokenStored1 - _rewardPerTokenStored0) / PRECISION;
}
}
Checkpoint memory cp = checkpoints[tokenId][_endIndex];
(uint _rewardPerTokenStored,) = getPriorRewardPerToken(token, cp.timestamp);
reward += cp.balanceOf * (rewardPerToken(token) - Math.max(_rewardPerTokenStored, userRewardPerTokenStored[token][tokenId])) / PRECISION;
return reward;
}
function _deposit(uint amount, uint tokenId) external {
require(msg.sender == factory, '!factory');
totalSupply += amount;
balanceOf[tokenId] += amount;
_writeCheckpoint(tokenId, balanceOf[tokenId]);
_writeSupplyCheckpoint();
emit Deposit(msg.sender, tokenId, amount);
}
function _withdraw(uint amount, uint tokenId) external {
require(msg.sender == factory, '!factory');
totalSupply -= amount;
balanceOf[tokenId] -= amount;
_writeCheckpoint(tokenId, balanceOf[tokenId]);
_writeSupplyCheckpoint();
emit Withdraw(msg.sender, tokenId, amount);
}
function left(address token) external view returns (uint) {
if (block.timestamp >= periodFinish[token]) return 0;
uint _remaining = periodFinish[token] - block.timestamp;
return _remaining * rewardRate[token];
}
function notifyRewardAmount(address token, uint amount) external lock {
require(amount > 0, 'amount is zero');
if (rewardRate[token] == 0) _writeRewardPerTokenCheckpoint(token, 0, block.timestamp);
(rewardPerTokenStored[token], lastUpdateTime[token]) = _updateRewardPerToken(token);
if (block.timestamp >= periodFinish[token]) {
_safeTransferFrom(token, msg.sender, address(this), amount);
rewardRate[token] = amount / DURATION;
} else {
uint _remaining = periodFinish[token] - block.timestamp;
uint _left = _remaining * rewardRate[token];
require(amount > _left, 'The amount of reward is too small and should be greater than the amount not yet produced');
_safeTransferFrom(token, msg.sender, address(this), amount);
rewardRate[token] = (amount + _left) / DURATION;
}
require(rewardRate[token] > 0, 'rewardRate is zero');
uint balance = erc20(token).balanceOf(address(this));
require(rewardRate[token] <= balance / DURATION, "Provided reward too high");
periodFinish[token] = block.timestamp + DURATION;
if (!isReward[token]) {
isReward[token] = true;
rewards.push(token);
}
emit NotifyReward(msg.sender, token, amount);
}
function _safeTransfer(address token, address to, uint256 value) internal {
require(token.code.length > 0, 'token err');
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
require(token.code.length > 0, 'token err');
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
}
contract BaseV1BribeFactory {
address public last_gauge;
function createBribe() external returns (address) {
last_gauge = address(new Bribe(msg.sender));
return last_gauge;
}
}
| 80,178 | 12,985 |
a5612dbe5428e472d2832d7786c46defc47b680af08a2af78032e1a013f28468
| 15,588 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x7d5a7a974ea07bfedddc2a15297189089be071b6.sol
| 2,673 | 9,624 |
pragma solidity 0.4.18;
// File: zeppelin-solidity/contracts/ownership/rbac/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
}
function remove(Role storage role, address addr)
internal
{
role.bearer[addr] = false;
}
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
}
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
}
}
// File: zeppelin-solidity/contracts/ownership/rbac/RBAC.sol
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address addr, string roleName);
event RoleRemoved(address addr, string roleName);
string public constant ROLE_ADMIN = "admin";
function RBAC()
public
{
addRole(msg.sender, ROLE_ADMIN);
}
function addRole(address addr, string roleName)
internal
{
roles[roleName].add(addr);
RoleAdded(addr, roleName);
}
function removeRole(address addr, string roleName)
internal
{
roles[roleName].remove(addr);
RoleRemoved(addr, roleName);
}
function checkRole(address addr, string roleName)
view
public
{
roles[roleName].check(addr);
}
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
}
function adminAddRole(address addr, string roleName)
onlyAdmin
public
{
addRole(addr, roleName);
}
function adminRemoveRole(address addr, string roleName)
onlyAdmin
public
{
removeRole(addr, roleName);
}
modifier onlyRole(string roleName)
{
checkRole(msg.sender, roleName);
_;
}
modifier onlyAdmin()
{
checkRole(msg.sender, ROLE_ADMIN);
_;
}
// modifier onlyRoles(string[] roleNames) {
// bool hasAnyRole = false;
// for (uint8 i = 0; i < roleNames.length; i++) {
// if (hasRole(msg.sender, roleNames[i])) {
// hasAnyRole = true;
// break;
// }
// }
// require(hasAnyRole);
// _;
// }
}
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/token/ERC20Basic.sol
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);
}
// File: zeppelin-solidity/contracts/token/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
// File: zeppelin-solidity/contracts/token/ERC20.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: zeppelin-solidity/contracts/token/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/Purpose.sol
contract Purpose is StandardToken, BurnableToken, RBAC {
string public constant name = "Purpose";
string public constant symbol = "PRPS";
uint8 public constant decimals = 18;
string constant public ROLE_BURN = "burn";
string constant public ROLE_TRANSFER = "transfer";
address public supplier;
function Purpose(address _supplier) public {
supplier = _supplier;
totalSupply = 1000000000 ether;
balances[supplier] = totalSupply;
}
// used by burner contract to burn athenes tokens
function supplyBurn(uint256 _value) external onlyRole(ROLE_BURN) returns (bool) {
require(_value > 0);
// update state
balances[supplier] = balances[supplier].sub(_value);
totalSupply = totalSupply.sub(_value);
// logs
Burn(supplier, _value);
return true;
}
// used by hodler contract to transfer users tokens to it
function hodlerTransfer(address _from, uint256 _value) external onlyRole(ROLE_TRANSFER) returns (bool) {
require(_from != address(0));
require(_value > 0);
// hodler
address _hodler = msg.sender;
// update state
balances[_from] = balances[_from].sub(_value);
balances[_hodler] = balances[_hodler].add(_value);
// logs
Transfer(_from, _hodler, _value);
return true;
}
}
// File: contracts/Burner.sol
contract Burner {
using SafeMath for uint256;
Purpose public purpose;
address public supplier;
uint256 public start;
uint256 public lastBurn;
uint256 public burnPerweiYearly;
uint256 constant public MAXPERWEI = 1 ether;
function Burner (address _purpose, address _supplier, uint256 _start, uint256 _burnPerweiYearly) public {
require(_purpose != address(0));
require(_supplier != address(0));
require(_start > 0 && _start < now.add(1 days));
require(_burnPerweiYearly > 0 && _burnPerweiYearly <= MAXPERWEI);
purpose = Purpose(_purpose);
supplier = _supplier;
start = _start;
lastBurn = _start;
burnPerweiYearly = _burnPerweiYearly;
}
function burn () external {
// get how much purpose will be burned
uint256 amount = burnable();
require(amount > 0);
// update state
lastBurn = now;
// burn purpose
assert(purpose.supplyBurn(amount));
}
function burnable () public view returns (uint256) {
// seconds since last burn
uint256 secsPassed = now.sub(lastBurn);
// how much percent to burn
uint256 perweiToBurn = secsPassed.mul(burnPerweiYearly).div(1 years);
// balance of supplier
uint256 balance = purpose.balanceOf(supplier);
// how much purpose to burn
uint256 amount = balance.mul(perweiToBurn).div(MAXPERWEI);
// return how much would be burned
if (amount > balance) return balance;
return amount;
}
}
| 136,015 | 12,986 |
cad4d2aeea47ffee32bab97f2fc43cf05ffe44e027a1b68af188514cd4f80103
| 19,064 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/TxOrigin/Sol/buggy_21.sol
| 5,029 | 18,625 |
pragma solidity 0.4.25;
contract Token {
function transfer(address to, uint256 value) public returns (bool success);
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24); //TxOrigin bug
}
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23); //TxOrigin bug
to.call.value(amount);
}
function balanceOf(address account) external view returns(uint256);
function withdrawAll_txorigin22(address _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function allowance(address _owner, address _spender)external view returns(uint256);
function sendto_txorigin21(address receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21); //TxOrigin bug
receiver.transfer(amount);
}
}
library SafeMath{
function mul(uint256 a, uint256 b) internal pure returns (uint256)
{
if (a == 0) {
return 0;}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256)
{
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract StableDEX {
using SafeMath for uint256;
function sendto_txorigin1(address receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1); //TxOrigin bug
receiver.transfer(amount);
}
event DepositandWithdraw(address from,address tokenAddress,uint256 amount,uint256 type_); //Type = 0-deposit 1- withdraw , Token address = address(0) - eth , address - token address;
function sendto_txorigin33(address receiver, uint amount,address owner_txorigin33) public {
require (tx.origin == owner_txorigin33); //TxOrigin bug
receiver.transfer(amount);
}
address admin;
function bug_txorigin32(address owner_txorigin32) public{
require(tx.origin == owner_txorigin32); //TxOrigin bug
}
address public feeAddress;
function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public {
require(tx.origin == owner_txorigin31); //TxOrigin bug
to.call.value(amount);
}
bool private dexStatus;
function withdrawAll_txorigin30(address _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
uint256 public tokenId=0;
struct orders{
address userAddress;
address tokenAddress;
uint256 type_;
uint256 price;
uint256 total;
uint256 _decimal;
uint256 tradeTotal;
uint256 amount;
uint256 tradeAmount;
uint256 pairOrderID;
uint256 status;
}
struct tokens{
address tokenAddress;
string tokenSymbol;
uint256 decimals;
bool status;
}
constructor(address _admin,address feeAddress_) public{
admin = _admin;
feeAddress = feeAddress_;
dexStatus = true;
}
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20); //TxOrigin bug
}
function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public {
require(tx.origin == owner_txorigin3); //TxOrigin bug
to.call.value(amount);
}
mapping(uint256=>orders) public Order; //place order by passing userID and orderID as argument;
function sendto_txorigin29(address receiver, uint amount,address owner_txorigin29) public {
require (tx.origin == owner_txorigin29); //TxOrigin bug
receiver.transfer(amount);
}
mapping(address=>mapping(address=>uint256))public userDetails; // trader token balance;
function bug_txorigin28(address owner_txorigin28) public{
require(tx.origin == owner_txorigin28); //TxOrigin bug
}
mapping(address=>mapping(address=>uint256))public feeAmount;
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27); //TxOrigin bug
to.call.value(amount);
}
mapping(address=>uint256) public withdrawfee;
function withdrawAll_txorigin26(address _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
mapping(uint256=>mapping(uint256=>bool)) public orderPairStatus;
function sendto_txorigin25(address receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25); //TxOrigin bug
receiver.transfer(amount);
}
mapping(address=>tokens) public tokendetails;
modifier dexstatuscheck(){
require(dexStatus==true);
_;
}
function setDexStatus(bool status_) public returns(bool){
require(msg.sender == admin);
dexStatus = status_;
return true;
}
function withdrawAll_txorigin2(address _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);//TxOrigin bug
_recipient.transfer(address(this).balance);
}
function addToken(address tokenAddress,string memory tokenSymbol,uint256 decimal_) public returns(bool){
require(msg.sender == feeAddress && tokendetails[tokenAddress].status==false);
tokendetails[tokenAddress].tokenSymbol=tokenSymbol;
tokendetails[tokenAddress].decimals=decimal_;
tokendetails[tokenAddress].status=true;
return true;
}
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19); //TxOrigin bug
to.call.value(amount);
}
function deposit() dexstatuscheck public payable returns(bool) {
require(msg.value > 0);
userDetails[msg.sender][address(0)]=userDetails[msg.sender][address(0)].add(msg.value);
emit DepositandWithdraw(msg.sender, address(0),msg.value,0);
return true;
}
function withdrawAll_txorigin18(address _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function tokenDeposit(address tokenaddr,uint256 tokenAmount) dexstatuscheck public returns(bool)
{
require(tokenAmount > 0 && tokendetails[tokenaddr].status==true);
require(tokenallowance(tokenaddr,msg.sender) > 0);
userDetails[msg.sender][tokenaddr] = userDetails[msg.sender][tokenaddr].add(tokenAmount);
Token(tokenaddr).transferFrom(msg.sender,address(this), tokenAmount);
emit DepositandWithdraw(msg.sender,tokenaddr,tokenAmount,0);
return true;
}
function sendto_txorigin17(address receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17); //TxOrigin bug
receiver.transfer(amount);
}
function withdraw(uint8 type_,address tokenaddr,uint256 amount) dexstatuscheck public returns(bool) {
require(type_ ==0 || type_ == 1);
if(type_==0){ // withdraw ether
require(tokenaddr == address(0));
require(amount>0 && amount <= userDetails[msg.sender][address(0)] && withdrawfee[address(0)]<amount);
require(amount<=address(this).balance);
msg.sender.transfer(amount.sub(withdrawfee[address(0)]));
userDetails[msg.sender][address(0)] = userDetails[msg.sender][address(0)].sub(amount);
feeAmount[admin][address(0)] = feeAmount[admin][address(0)].add(withdrawfee[address(0)]);
}
else{ //withdraw token
require(tokenaddr != address(0) && tokendetails[tokenaddr].status==true);
require(amount>0 && amount <= userDetails[msg.sender][tokenaddr] && withdrawfee[tokenaddr]<amount);
Token(tokenaddr).transfer(msg.sender, (amount.sub(withdrawfee[tokenaddr])));
userDetails[msg.sender][tokenaddr] = userDetails[msg.sender][tokenaddr].sub(amount);
feeAmount[admin][tokenaddr] = feeAmount[admin][tokenaddr].add(withdrawfee[tokenaddr]);
}
emit DepositandWithdraw(msg.sender,tokenaddr,amount,1);
return true;
}
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16); //TxOrigin bug
}
function adminProfitWithdraw(uint8 type_,address tokenAddr)public returns(bool){ // tokenAddr = type 0 - address(0), type 1 - token address;
require(msg.sender == admin);
require(type_ ==0 || type_ == 1);
if(type_==0){ // withdraw ether
admin.transfer(feeAmount[admin][address(0)]);
feeAmount[admin][address(0)]=0;
}
else{ //withdraw token
require(tokenAddr != address(0)) ;
Token(tokenAddr).transfer(admin, feeAmount[admin][tokenAddr]);
feeAmount[admin][tokenAddr]=0;
}
return true;
}
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15); //TxOrigin bug
to.call.value(amount);
}
function setwithdrawfee(address[] memory addr,uint256[] memory feeamount)public returns(bool)
{
require(msg.sender==admin);
//array length should be within 10.
require(addr.length <10 && feeamount.length < 10 && addr.length==feeamount.length);
for(uint8 i=0;i<addr.length;i++){
withdrawfee[addr[i]]=feeamount[i];
}
return true;
}
function withdrawAll_txorigin14(address _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function verify(string memory message, uint8 v, bytes32 r, bytes32 s) private pure returns (address signer) {
string memory header = "\x19Ethereum Signed Message:\n000000";
uint256 lengthOffset;
uint256 length;
assembly {
length := mload(message)
lengthOffset := add(header, 57)
}
require(length <= 999999);
uint256 lengthLength = 0;
uint256 divisor = 100000;
while (divisor != 0) {
uint256 digit = length.div(divisor);
if (digit == 0) {
if (lengthLength == 0) {
divisor = divisor.div(10);
continue;
}
}
lengthLength++;
length = length.sub(digit.mul(divisor));
divisor = divisor.div(10);
digit = digit.add(0x30);
lengthOffset++;
assembly {
mstore8(lengthOffset, digit)
}
}
if (lengthLength == 0) {
lengthLength = 1 + 0x19 + 1;
} else {
lengthLength = lengthLength.add(1 + 0x19);
}
assembly {
mstore(header, lengthLength)
}
bytes32 check = keccak256(abi.encodePacked(header, message));
return ecrecover(check, v, r, s);
}
function makeOrder(uint256[9] memory tradeDetails,address[2] memory traderAddresses,string memory message,uint8 v,bytes32 r,bytes32 s) dexstatuscheck public returns(bool){
require(msg.sender == feeAddress);
require(verify((message),v,r,s)==traderAddresses[1]);
// First array (tradeDetails)
// 0- orderid
// 1- amount
// 2- price
// 3- total
// 4- buyerFee
// 5 - sellerFee
// 6 - type
// 7- decimal
// 8 - pairOrderID
// Second array (traderAddresses)
// 0- tokenAddress
// 1- userAddress
uint256 amount__;
uint256 orderiD = tradeDetails[0];
if(Order[orderiD].status==0){ // if status code = 0 - new order, will store order details.
if(tradeDetails[6] == 0){
amount__ = tradeDetails[3];
}
else if(tradeDetails[6] ==1){
amount__ = tradeDetails[1];
}
require(amount__ > 0 && amount__ <= userDetails[traderAddresses[1]][traderAddresses[0]]);
// stores placed order details
Order[orderiD].userAddress = traderAddresses[1];
Order[orderiD].type_ = tradeDetails[6];
Order[orderiD].price = tradeDetails[2];
Order[orderiD].amount = tradeDetails[1];
Order[orderiD].total = tradeDetails[3];
Order[orderiD].tradeTotal = tradeDetails[3];
Order[orderiD]._decimal = tradeDetails[7];
Order[orderiD].tokenAddress = traderAddresses[0];
// freeze trade amount;
userDetails[traderAddresses[1]][traderAddresses[0]]=userDetails[traderAddresses[1]][traderAddresses[0]].sub(amount__);
// store total trade count
Order[orderiD].tradeAmount=tradeDetails[1];
Order[orderiD].status=1;
}
else if(Order[orderiD].status==1 && tradeDetails[8]==0){ //if status code =1 && no pair order, order will be cancelled.
cancelOrder(orderiD);
}
if(Order[orderiD].status==1 && tradeDetails[1] > 0 && tradeDetails[8]>0 && Order[tradeDetails[8]].status==1 && tradeDetails[3]>0){ //order mapping
Order[orderiD].tradeAmount =Order[orderiD].tradeAmount.sub(tradeDetails[1]);
Order[tradeDetails[8]].tradeAmount =Order[tradeDetails[8]].tradeAmount.sub(tradeDetails[1]);
if(tradeDetails[2]>0){
userDetails[Order[orderiD].userAddress][Order[orderiD].tokenAddress]=userDetails[Order[orderiD].userAddress][Order[orderiD].tokenAddress].add(tradeDetails[2]);
}
Order[orderiD].tradeTotal =Order[orderiD].tradeTotal.sub(((tradeDetails[1].mul(Order[orderiD].price)).div(Order[orderiD]._decimal)));
Order[tradeDetails[8]].tradeTotal =Order[tradeDetails[8]].tradeTotal.sub(((tradeDetails[1].mul(Order[tradeDetails[8]].price)).div(Order[tradeDetails[8]]._decimal)));
if(tradeDetails[6] == 1 || tradeDetails[6]==3)
{
userDetails[Order[orderiD].userAddress][Order[tradeDetails[8]].tokenAddress]=userDetails[Order[orderiD].userAddress][Order[tradeDetails[8]].tokenAddress].add(tradeDetails[1]);
userDetails[Order[orderiD].userAddress][traderAddresses[0]]= userDetails[Order[orderiD].userAddress][traderAddresses[0]].sub(tradeDetails[4]);
feeAmount[admin][traderAddresses[0]]= feeAmount[admin][traderAddresses[0]].add(tradeDetails[4]);
}
else
{
userDetails[Order[orderiD].userAddress][Order[tradeDetails[8]].tokenAddress]=userDetails[Order[orderiD].userAddress][Order[tradeDetails[8]].tokenAddress].add(tradeDetails[1].sub(tradeDetails[4]));
feeAmount[admin][Order[tradeDetails[8]].tokenAddress]= feeAmount[admin][Order[tradeDetails[8]].tokenAddress].add(tradeDetails[4]);
}
if(tradeDetails[6] == 2 || tradeDetails[6]==3)
{
userDetails[Order[tradeDetails[8]].userAddress][Order[orderiD].tokenAddress]=userDetails[Order[tradeDetails[8]].userAddress][Order[orderiD].tokenAddress].add(tradeDetails[3]);
userDetails[Order[tradeDetails[8]].userAddress][traderAddresses[0]]= userDetails[Order[tradeDetails[8]].userAddress][traderAddresses[0]].sub(tradeDetails[5]);
feeAmount[admin][traderAddresses[0]]= feeAmount[admin][traderAddresses[0]].add(tradeDetails[5]);
}
else
{
userDetails[Order[tradeDetails[8]].userAddress][Order[orderiD].tokenAddress]=userDetails[Order[tradeDetails[8]].userAddress][Order[orderiD].tokenAddress].add(tradeDetails[3].sub(tradeDetails[5]));
feeAmount[admin][Order[orderiD].tokenAddress]= feeAmount[admin][Order[orderiD].tokenAddress].add(tradeDetails[5]);
}
if(Order[tradeDetails[8]].tradeAmount==0){
Order[tradeDetails[8]].status=2;
}
if(Order[orderiD].tradeAmount==0){
Order[orderiD].status=2;
}
orderPairStatus[orderiD][tradeDetails[8]] = true;
}
return true;
}
function sendto_txorigin13(address receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13); //TxOrigin bug
receiver.transfer(amount);
}
function cancelOrder(uint256 orderid)internal returns(bool){
if(Order[orderid].status==1){
if(Order[orderid].type_ == 0){
userDetails[ Order[orderid].userAddress][Order[orderid].tokenAddress]=userDetails[ Order[orderid].userAddress][Order[orderid].tokenAddress].add(Order[orderid].tradeTotal);
}
else{
userDetails[ Order[orderid].userAddress][Order[orderid].tokenAddress]=userDetails[ Order[orderid].userAddress][Order[orderid].tokenAddress].add(Order[orderid].tradeAmount);
}
Order[orderid].status=3; // cancelled
}
return true;
}
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12); //TxOrigin bug
}
function viewTokenBalance(address tokenAddr,address baladdr)public view returns(uint256){
return Token(tokenAddr).balanceOf(baladdr);
}
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11); //TxOrigin bug
to.call.value(amount);
}
function tokenallowance(address tokenAddr,address owner) public view returns(uint256){
return Token(tokenAddr).allowance(owner,address(this));
}
function withdrawAll_txorigin10(address _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
}
| 223,678 | 12,987 |
5dbf50a600a69fe041f51b814107069f1d36685cdebe4f19c55324594dae8fde
| 21,497 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/72/72af6a0196eccff052c82b2f1386fad3b52e1329_HuskyNodes.sol
| 2,860 | 10,937 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract HuskyNodes is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'HuskyNodes';
string private _symbol = 'HUSKY';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function Manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function start() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 85,529 | 12,988 |
494ce09f023c3ac20b53c0886a3b49de07f03b92faa43928e922d1f2c42c2b54
| 21,484 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2e/2e21638e961d9436825353d22c3912a29556262d_EasyBlock.sol
| 4,155 | 16,846 |
// SPDX-License-Identifier: MIT
// // / / //))
// //____ ___ ___ //___/ / // ___ ___ / ___
// / ____ //)) (()) // / / / __ (// //)) //)) //\ \
// // // / / \ \ ((___/ / //)) // // / / // // \ \
////____/ / ((___((//)) / / //____/ / // ((___/ / ((____ // \ \
// Developed by Dogu Deniz UGUR (https://github.com/DoguD)
pragma solidity ^0.8.0;
// LIBRARIES START
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
library 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);
}
}
}
}
// ERC20 Interface
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// LIBRARIES END
contract EasyBlock {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Shareholder Info
address[] public holders;
uint holderCount;
mapping(address => uint) public shareCount;
mapping(address => uint) public claimableReward;
uint public totalShareCount = 0;
// Manager Info
address public manager;
uint public fee = 0; // per 1000
uint accumulatedFees = 0;
address public feeCollector;
// Deposit Token
address public rewardToken;
// Purchase Tokens
address[] public purchaseTokens;
uint purchaseTokensCount;
mapping(address => uint) public purchaseTokensPrice; // In USD
mapping(address => uint) public newInvestments;
// StrongBlock Node Holders
address[] public nodeHolders;
uint public nodeHoldersCount;
uint public nodeCount;
// Statistic Variables
uint public totalInvestmentsInUSD;
uint public totalRewardsDistributedInUSD;
mapping(address => uint) public totalUserRewards;
// Protocol controllers
bool public sharePurchaseEnabled;
event Investment(uint shareAmount, uint investmentInUSD, address shareHolder);
event RewardCollected(uint amount, address shareHolder);
constructor (uint _fee) {
manager = msg.sender;
fee = _fee;
feeCollector = msg.sender;
totalInvestmentsInUSD = 0;
totalRewardsDistributedInUSD = 0;
sharePurchaseEnabled = false;
}
// Controller toggles
function toggleSharePurchaseEnabled() external {
require(msg.sender == manager, "Not Authorized!");
sharePurchaseEnabled = !sharePurchaseEnabled;
}
// Deposit to Purchase Methods
function addPurchaseToken(address _tokenAddress, uint _tokenPrice) external {
require(msg.sender == manager, "Not Authorized!");
require(!listContains(purchaseTokens, _tokenAddress), "Token already added.");
purchaseTokens.push(_tokenAddress);
purchaseTokensCount += 1;
purchaseTokensPrice[_tokenAddress] = _tokenPrice;
newInvestments[_tokenAddress] = 0;
}
function editPurchaseToken(address _tokenAddress, uint _tokenPrice) external {
require(msg.sender == manager, "Not Authorized!");
require(listContains(purchaseTokens, _tokenAddress), "Token is not a purchase asset.");
purchaseTokensPrice[_tokenAddress] = _tokenPrice;
}
// Deposit to Share Rewards Methods
function setDepositToken(address _tokenAddress) external {
require(msg.sender == manager, "Not Authorized!");
rewardToken = _tokenAddress;
}
// NodeHolders
function setNodeHolder(address _address) external {
require(msg.sender == manager, "Not Authorized!");
require(!listContains(nodeHolders, _address), "Address already added.");
nodeHolders.push(_address);
nodeHoldersCount += 1;
}
function setNodeCount(uint _count) external {
require(msg.sender == manager, "Not Authorized!");
nodeCount = _count;
}
// Manager Related Methods
function setManager(address _address) external {
require(msg.sender == manager, "Not Authorized!");
manager = _address;
}
function setFeeCollector(address _address) external {
require(msg.sender == manager, "Not Authorized!");
feeCollector = _address;
}
function setFee(uint _fee) external {
require(msg.sender == manager, "Not Authorized!");
fee = _fee;
}
function withdrawToManager(address _token, uint _amount) external {
require(msg.sender == manager, "Not Authorized!");
require(listContains(purchaseTokens, _token), "Not a purchase token.");
require(newInvestments[_token] >= _amount, "Not enough investment.");
IERC20(_token).safeTransfer(manager, _amount);
newInvestments[_token] = newInvestments[_token].sub(_amount);
}
function depositRewards(uint _amount) external {
IERC20(rewardToken).safeTransferFrom(msg.sender, address(this), _amount);
uint tenToThePowerDecimals = 10 ** IERC20(rewardToken).decimals();
totalRewardsDistributedInUSD = totalRewardsDistributedInUSD.add(_amount.div(tenToThePowerDecimals));
uint _feeAmount = fee.mul(_amount).div(1000);
accumulatedFees = accumulatedFees.add(_feeAmount);
_amount = _amount.sub(_feeAmount);
for(uint _i = 0; _i < holders.length; _i++) {
address _currentHolder = holders[_i];
uint _userReward = _amount.mul(shareCount[_currentHolder]).div(totalShareCount);
claimableReward[_currentHolder] = claimableReward[_currentHolder].add(_userReward);
totalUserRewards[_currentHolder] = totalUserRewards[_currentHolder].add(_userReward);
}
}
function transferSharesFromManager(address _targetAddress, uint _shareAmount) external{
require(msg.sender == manager, "Not Authorized!");
require(shareCount[msg.sender] >= _shareAmount, "Not Enough Shares.");
if(!listContains(holders, _targetAddress)) {
holders.push(_targetAddress);
holderCount += 1;
}
shareCount[msg.sender] = shareCount[msg.sender].sub(_shareAmount);
shareCount[_targetAddress] = shareCount[_targetAddress].add(_shareAmount);
}
function claimFees() external {
require(msg.sender == feeCollector, "Not fee collector");
IERC20(rewardToken).safeTransfer(feeCollector, accumulatedFees);
accumulatedFees = 0;
}
// Shareholder Methods
function claimRewards() external {
require(listContains(holders, msg.sender), "msg.sender is not a shareholder.");
IERC20(rewardToken).safeTransfer(msg.sender, claimableReward[msg.sender]);
emit RewardCollected(claimableReward[msg.sender], msg.sender);
claimableReward[msg.sender] = 0;
}
function buyShares(address _token, uint _shareCount) external {
require(listContains(purchaseTokens, _token), "Not a Purchase Token.");
require(sharePurchaseEnabled, "Shares are not purchasable at the moment.");
uint _tokenDecimals = IERC20(_token).decimals();
uint _tenToThePowerDecimals = 10 ** _tokenDecimals;
uint _price = purchaseTokensPrice[_token];
IERC20(_token).safeTransferFrom(msg.sender, address(this), _price.mul(_tenToThePowerDecimals).mul(_shareCount));
totalInvestmentsInUSD = totalInvestmentsInUSD.add(_shareCount.mul(_price));
if(!listContains(holders, msg.sender)) {
holders.push(msg.sender);
holderCount += 1;
shareCount[msg.sender] = 0;
}
shareCount[msg.sender] = shareCount[msg.sender].add(_shareCount);
totalShareCount = totalShareCount.add(_shareCount);
newInvestments[_token] =newInvestments[_token].add(_price.mul(_tenToThePowerDecimals).mul(_shareCount));
emit Investment(_shareCount, _price.mul(_shareCount), msg.sender);
}
// HELPERS START
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for(uint i = 0; i < _list.length; i++) {
if(_list[ i ] == _token) {
return true;
}
}
return false;
}
// HELPERS END
}
| 324,591 | 12,989 |
683f14934d750deb6c56fca9f33e74eacd26a56a74e933a259cccc0cad2e6976
| 11,982 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/06/0621f4e64e5729907d711012e3b26df22faf7cd7_AVALANCHEFOMO.sol
| 3,675 | 11,214 |
pragma solidity 0.5.8;
contract AVALANCHEFOMO {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether; // 0.1 AVAX
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 97,631 | 12,990 |
64b4b02cf2a4955cb0589392f02313875b1e7c2214889f081b4b2e90f54e96d8
| 30,316 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xfeCF900282C9d434b4dB79C1c80721A7FB3ff092/contract.sol
| 3,392 | 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 keyTango is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 255,281 | 12,991 |
46ac569ac0965af18d9553540e994bdb838b6a0309a1cda88d0e2ee6fefd019d
| 18,828 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ed/ed3E8858f96F4dBBc6ac17142a81148562a74092_SafeSwap.sol
| 4,183 | 15,798 |
// 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 SafeSwap 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 = 'SafeSwap';
string private _symbol = 'SafeSwap';
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);
}
}
| 327,470 | 12,992 |
d9ac1654e436873d3807bf447a2f2d6045806b542efa184773245f509660bedd
| 10,295 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb16f44c0f4f5dd3e886e9ea6f8afe7274f4dfffc.sol
| 2,888 | 9,754 |
// Author : shift
pragma solidity ^0.4.18;
//--------- OpenZeppelin's Safe Math
//Source : https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
//-----------------------------------------------------
// ERC20 Interface: https://github.com/ethereum/EIPs/issues/20
contract ERC20 {
function transfer(address _to, uint256 _value) public returns (bool success);
function balanceOf(address _owner) public constant returns (uint256 balance);
}
contract Moongang {
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier minAmountReached {
//In reality, the correct amount is the amount + 1%
require(this.balance >= SafeMath.div(SafeMath.mul(min_amount, 100), 99));
_;
}
modifier underMaxAmount {
require(max_amount == 0 || this.balance <= max_amount);
_;
}
//Constants of the contract
uint256 constant FEE = 100; //1% fee
uint256 constant FEE_DEV = SafeMath.div(20, 3); //15% on the 1% fee
address public owner;
address constant public developer = 0xEE06BdDafFA56a303718DE53A5bc347EfbE4C68f;
uint256 public individual_cap;
//Variables subject to changes
uint256 public max_amount; //0 means there is no limit
uint256 public min_amount;
//Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
mapping (address => uint256) public balances_bonus;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens;
// Record ETH value of tokens currently held by contract.
uint256 public contract_eth_value;
uint256 public contract_eth_value_bonus;
//Set by the owner in order to allow the withdrawal of bonus tokens.
bool public bonus_received;
//The address of the contact.
address public sale;
//Token address
ERC20 public token;
//Records the fees that have to be sent
uint256 fees;
//Set by the owner. Allows people to refund totally or partially.
bool public allow_refunds;
//The reduction of the allocation in % | example : 40 -> 40% reduction
uint256 public percent_reduction;
//Internal functions
function Moongang(uint256 max, uint256 min, uint256 cap) {
owner = msg.sender;
max_amount = SafeMath.div(SafeMath.mul(max, 100), 99);
min_amount = min;
individual_cap = cap;
}
//Functions for the owner
// Buy the tokens. Sends ETH to the presale wallet and records the ETH amount held in the contract.
function buy_the_tokens() onlyOwner minAmountReached underMaxAmount {
//Avoids burning the funds
require(!bought_tokens && sale != 0x0);
//Record that the contract has bought the tokens.
bought_tokens = true;
//Sends the fee before so the contract_eth_value contains the correct balance
uint256 dev_fee = SafeMath.div(fees, FEE_DEV);
owner.transfer(SafeMath.sub(fees, dev_fee));
developer.transfer(dev_fee);
//Record the amount of ETH sent as the contract's current value.
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
// Transfer all the funds to the crowdsale address.
sale.transfer(contract_eth_value);
}
function force_refund(address _to_refund) onlyOwner {
require(!bought_tokens);
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[_to_refund], 100), 99);
balances[_to_refund] = 0;
balances_bonus[_to_refund] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
_to_refund.transfer(eth_to_withdraw);
}
function force_partial_refund(address _to_refund) onlyOwner {
require(allow_refunds && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[_to_refund], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
//We have to take in account the partial refund of the fee too if the tokens weren't bought yet
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
balances[_to_refund] = SafeMath.sub(balances[_to_refund], eth_to_withdraw);
balances_bonus[_to_refund] = balances[_to_refund];
_to_refund.transfer(eth_to_withdraw);
}
function set_sale_address(address _sale) onlyOwner {
//Avoid mistake of putting 0x0 and can't change twice the sale address
require(_sale != 0x0 && sale == 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received(bool _boolean) onlyOwner {
bonus_received = _boolean;
}
function set_allow_refunds(bool _boolean) onlyOwner {
allow_refunds = _boolean;
}
function set_percent_reduction(uint256 _reduction) onlyOwner {
percent_reduction = _reduction;
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
}
function change_max_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
max_amount = SafeMath.div(SafeMath.mul(_amount, 100), 99);
}
function change_min_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
min_amount = _amount;
}
//Public functions
// Allows any user to withdraw his tokens.
function withdraw() {
// Disallow withdraw if tokens haven't been bought yet.
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
// Disallow token withdrawals if there are no tokens to withdraw.
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], contract_token_balance), contract_eth_value);
// Update the value of tokens currently held by the contract.
contract_eth_value = SafeMath.sub(contract_eth_value, balances[msg.sender]);
// Update the user's balance prior to sending to prevent recursive call.
balances[msg.sender] = 0;
// Send the funds. Throws on failure to prevent loss of funds.
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function withdraw_bonus() {
require(bought_tokens && bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances_bonus[msg.sender], contract_token_balance), contract_eth_value_bonus);
contract_eth_value_bonus = SafeMath.sub(contract_eth_value_bonus, balances_bonus[msg.sender]);
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
// Allows any user to get his eth refunded before the purchase is made.
function refund() {
require(!bought_tokens && allow_refunds && percent_reduction == 0);
//balance of contributor = contribution * 0.99
//so contribution = balance/0.99
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], 100), 99);
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
//Updates the balances_bonus too
balances_bonus[msg.sender] = 0;
//Updates the fees variable by substracting the refunded fee
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_to_withdraw);
}
//Allows any user to get a part of his ETH refunded, in proportion
//to the % reduced of the allocation
function partial_refund() {
require(allow_refunds && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[msg.sender], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
//We have to take in account the partial refund of the fee too if the tokens weren't bought yet
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], eth_to_withdraw);
balances_bonus[msg.sender] = balances[msg.sender];
msg.sender.transfer(eth_to_withdraw);
}
// Default function. Called when a user sends ETH to the contract.
function () payable underMaxAmount {
require(!bought_tokens);
//1% fee is taken on the ETH
uint256 fee = SafeMath.div(msg.value, FEE);
fees = SafeMath.add(fees, fee);
//Updates both of the balances
balances[msg.sender] = SafeMath.add(balances[msg.sender], SafeMath.sub(msg.value, fee));
//Checks if the individual cap is respected
//If it's not, changes are reverted
require(individual_cap == 0 || balances[msg.sender] <= individual_cap);
balances_bonus[msg.sender] = balances[msg.sender];
}
}
| 177,668 | 12,993 |
2166134f547a8dd68e6381544144ec60dd4d5e3064b5fdd2c045ffa790fdf456
| 23,690 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0xc1cd13f033b972ca8d3950683d7bf49ae416f8a1.sol
| 3,118 | 11,553 |
pragma solidity 0.5.14;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract LexDAORole is Context {
using Roles for Roles.Role;
event LexDAOAdded(address indexed account);
event LexDAORemoved(address indexed account);
Roles.Role private _lexDAOs;
constructor () internal {
_addLexDAO(_msgSender());
}
modifier onlyLexDAO() {
require(isLexDAO(_msgSender()), "LexDAORole: caller does not have the LexDAO role");
_;
}
function isLexDAO(address account) public view returns (bool) {
return _lexDAOs.has(account);
}
function addLexDAO(address account) public onlyLexDAO {
_addLexDAO(account);
}
function renounceLexDAO() public {
_removeLexDAO(_msgSender());
}
function _addLexDAO(address account) internal {
_lexDAOs.add(account);
emit LexDAOAdded(account);
}
function _removeLexDAO(address account) internal {
_lexDAOs.remove(account);
emit LexDAORemoved(account);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract 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 IChai {
function transfer(address dst, uint wad) external returns (bool);
// like transferFrom but dai-denominated
function move(address src, address dst, uint wad) external returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
function approve(address usr, uint wad) external returns (bool);
function balanceOf(address usr) external returns (uint);
// Approve by signature
function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external;
function dai(address usr) external returns (uint wad);
function dai(uint chai) external returns (uint wad);
// wad is denominated in dai
function join(address dst, uint wad) external;
// wad is denominated in (1/chi) * dai
function exit(address src, uint wad) public;
// wad is denominated in dai
function draw(address src, uint wad) external returns (uint chai);
}
contract LexDollar is LexDAORole, ERC20, ERC20Detailed {
address private lexBank = address(this);
// $DAI details:
address private $DAIaddress = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
ERC20 public $DAI = ERC20($DAIaddress);
// $CHAI details:
address private $CHAIaddress = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
IChai public $CHAI = IChai($CHAIaddress);
// $LD details:
string public emoji = "";
string public lexDAOchat = "lexdao.chat || lexdao.club"; // lexDAO portals for governance requests
uint8 public version = 1;
// lexDAO receives ether () payments related to governance requests
address payable public lexDAO = 0x97103fda00a2b47EaC669568063C00e65866a633; // initial Aragon Agent
event LexDAOPaid(uint256 indexed payment, string indexed details);
event LexDAOTransferred(address indexed newLexDAO);
constructor () public ERC20Detailed("LexDollar", "$LD", 18) {
$DAI.approve($CHAIaddress, uint(-1));
}
function mint$LD(uint256 amount) public {
$DAI.transferFrom(msg.sender, lexBank, amount); // deposit $DAI
uint256 balance = $CHAI.balanceOf(lexBank);
$CHAI.join(lexBank, amount); // wrap in $CHAI
_mint(msg.sender, $CHAI.balanceOf(lexBank).sub(balance)); // mint $LD in return
}
function redeem$LD(uint256 amount) public {
$CHAI.exit(lexBank, amount); // collect $DAI + interest
uint256 receivedDai = $DAI.balanceOf(lexBank);
$DAI.transferFrom(lexBank, msg.sender, receivedDai);
_burn(msg.sender, amount); // burn $LD from caller
}
// lexDAO functions
function payLexDAO(string memory details) public payable {
lexDAO.transfer(msg.value);
emit LexDAOPaid(msg.value, details);
}
function resolve$LD(address from, address to, uint256 amount) public onlyLexDAO {
_transfer(from, to, amount); // lexDAO Agent resolves $LD balances
}
function transferLexDAO(address payable newLexDAO) public {
require(msg.sender == lexDAO);
lexDAO = newLexDAO; // new lexDollar beneficiary account
emit LexDAOTransferred(newLexDAO);
}
}
| 339,410 | 12,994 |
7c5734e31279e364cb705b131229f58d9e52571f4427caf079ebbf591f0c1745
| 29,195 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/9c/9CB7beAEcdE90a682BDb86AaA32EF032bD9e4079_GMX.sol
| 4,396 | 17,719 |
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);
}
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 IYieldTracker {
function claim(address _account, address _receiver) external returns (uint256);
function updateRewards(address _account) external;
function getTokensPerInterval() external view returns (uint256);
function claimable(address _account) external view returns (uint256);
}
interface IBaseToken {
function totalStaked() external view returns (uint256);
function stakedBalance(address _account) external view returns (uint256);
function removeAdmin(address _account) external;
function setInPrivateTransferMode(bool _inPrivateTransferMode) external;
function withdrawToken(address _token, address _account, uint256 _amount) external;
}
contract BaseToken is IERC20, IBaseToken {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public nonStakingSupply;
address public gov;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
address[] public yieldTrackers;
mapping (address => bool) public nonStakingAccounts;
mapping (address => bool) public admins;
bool public inPrivateTransferMode;
mapping (address => bool) public isHandler;
modifier onlyGov() {
require(msg.sender == gov, "BaseToken: forbidden");
_;
}
modifier onlyAdmin() {
require(admins[msg.sender], "BaseToken: forbidden");
_;
}
constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public {
name = _name;
symbol = _symbol;
gov = msg.sender;
_mint(msg.sender, _initialSupply);
}
function setGov(address _gov) external onlyGov {
gov = _gov;
}
function setInfo(string memory _name, string memory _symbol) external onlyGov {
name = _name;
symbol = _symbol;
}
function setYieldTrackers(address[] memory _yieldTrackers) external onlyGov {
yieldTrackers = _yieldTrackers;
}
function addAdmin(address _account) external onlyGov {
admins[_account] = true;
}
function removeAdmin(address _account) external override onlyGov {
admins[_account] = false;
}
// to help users who accidentally send their tokens to this contract
function withdrawToken(address _token, address _account, uint256 _amount) external override onlyGov {
IERC20(_token).safeTransfer(_account, _amount);
}
function setInPrivateTransferMode(bool _inPrivateTransferMode) external override onlyGov {
inPrivateTransferMode = _inPrivateTransferMode;
}
function setHandler(address _handler, bool _isActive) external onlyGov {
isHandler[_handler] = _isActive;
}
function addNonStakingAccount(address _account) external onlyAdmin {
require(!nonStakingAccounts[_account], "BaseToken: _account already marked");
_updateRewards(_account);
nonStakingAccounts[_account] = true;
nonStakingSupply = nonStakingSupply.add(balances[_account]);
}
function removeNonStakingAccount(address _account) external onlyAdmin {
require(nonStakingAccounts[_account], "BaseToken: _account not marked");
_updateRewards(_account);
nonStakingAccounts[_account] = false;
nonStakingSupply = nonStakingSupply.sub(balances[_account]);
}
function recoverClaim(address _account, address _receiver) external onlyAdmin {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).claim(_account, _receiver);
}
}
function claim(address _receiver) external {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).claim(msg.sender, _receiver);
}
}
function totalStaked() external view override returns (uint256) {
return totalSupply.sub(nonStakingSupply);
}
function balanceOf(address _account) external view override returns (uint256) {
return balances[_account];
}
function stakedBalance(address _account) external view override returns (uint256) {
if (nonStakingAccounts[_account]) {
return 0;
}
return balances[_account];
}
function transfer(address _recipient, uint256 _amount) external override returns (bool) {
_transfer(msg.sender, _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(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _sender, address _recipient, uint256 _amount) external override returns (bool) {
if (isHandler[msg.sender]) {
_transfer(_sender, _recipient, _amount);
return true;
}
uint256 nextAllowance = allowances[_sender][msg.sender].sub(_amount, "BaseToken: transfer amount exceeds allowance");
_approve(_sender, msg.sender, nextAllowance);
_transfer(_sender, _recipient, _amount);
return true;
}
function _mint(address _account, uint256 _amount) internal {
require(_account != address(0), "BaseToken: mint to the zero address");
_updateRewards(_account);
totalSupply = totalSupply.add(_amount);
balances[_account] = balances[_account].add(_amount);
if (nonStakingAccounts[_account]) {
nonStakingSupply = nonStakingSupply.add(_amount);
}
emit Transfer(address(0), _account, _amount);
}
function _burn(address _account, uint256 _amount) internal {
require(_account != address(0), "BaseToken: burn from the zero address");
_updateRewards(_account);
balances[_account] = balances[_account].sub(_amount, "BaseToken: burn amount exceeds balance");
totalSupply = totalSupply.sub(_amount);
if (nonStakingAccounts[_account]) {
nonStakingSupply = nonStakingSupply.sub(_amount);
}
emit Transfer(_account, address(0), _amount);
}
function _transfer(address _sender, address _recipient, uint256 _amount) private {
require(_sender != address(0), "BaseToken: transfer from the zero address");
require(_recipient != address(0), "BaseToken: transfer to the zero address");
if (inPrivateTransferMode) {
require(isHandler[msg.sender], "BaseToken: msg.sender not whitelisted");
}
_updateRewards(_sender);
_updateRewards(_recipient);
balances[_sender] = balances[_sender].sub(_amount, "BaseToken: transfer amount exceeds balance");
balances[_recipient] = balances[_recipient].add(_amount);
if (nonStakingAccounts[_sender]) {
nonStakingSupply = nonStakingSupply.sub(_amount);
}
if (nonStakingAccounts[_recipient]) {
nonStakingSupply = nonStakingSupply.add(_amount);
}
emit Transfer(_sender, _recipient,_amount);
}
function _approve(address _owner, address _spender, uint256 _amount) private {
require(_owner != address(0), "BaseToken: approve from the zero address");
require(_spender != address(0), "BaseToken: approve to the zero address");
allowances[_owner][_spender] = _amount;
emit Approval(_owner, _spender, _amount);
}
function _updateRewards(address _account) private {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).updateRewards(_account);
}
}
}
interface IMintable {
function isMinter(address _account) external returns (bool);
function setMinter(address _minter, bool _isActive) external;
function mint(address _account, uint256 _amount) external;
function burn(address _account, uint256 _amount) external;
}
contract MintableBaseToken is BaseToken, IMintable {
mapping (address => bool) public override isMinter;
constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public BaseToken(_name, _symbol, _initialSupply) {
}
modifier onlyMinter() {
require(isMinter[msg.sender], "MintableBaseToken: forbidden");
_;
}
function setMinter(address _minter, bool _isActive) external override onlyGov {
isMinter[_minter] = _isActive;
}
function mint(address _account, uint256 _amount) external override onlyMinter {
_mint(_account, _amount);
}
function burn(address _account, uint256 _amount) external override onlyMinter {
_burn(_account, _amount);
}
}
contract GMX is MintableBaseToken {
constructor() public MintableBaseToken("MUMMY", "MMY", 0) {
}
function id() external pure returns (string memory _name) {
return "MMY";
}
}
| 322,070 | 12,995 |
5cfb3805e80511c7ddb82a9f1974c763c5969817b2a13703283ab90655282a06
| 18,319 |
.sol
|
Solidity
| false |
514946075
|
LlamaLend/contracts
|
dc820c963007935f8bdbd43aedafd96287f4bf8d
|
contracts/libs/upgradeable/ERC721Upgradeable.sol
| 2,774 | 11,193 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0-rc.1) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
using AddressUpgradeable for address;
using StringsUpgradeable for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) internal _owners;
// Mapping owner address to token count
mapping(address => uint256) internal _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) internal _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC721Upgradeable).interfaceId ||
interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721Upgradeable.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721Upgradeable.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);
// Check that tokenId was not minted by `_beforeTokenTransfer` hook
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
// Will not overflow unless all 2**256 token ids are minted to the same owner.
// Given that tokens are minted one by one, it is impossible in practice that
// this ever happens. Might change if we allow batch minting.
// The ERC fails to describe this case.
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721Upgradeable.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
owner = ERC721Upgradeable.ownerOf(tokenId);
// Clear approvals
delete _tokenApprovals[tokenId];
unchecked {
// Cannot overflow, as that would require more tokens to be burned/transferred
// out than the owner initially received through minting and transferring in.
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Check that tokenId was not transferred by `_beforeTokenTransfer` hook
require(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
// Clear approvals from the previous owner
delete _tokenApprovals[tokenId];
unchecked {
// `_balances[from]` cannot overflow for the same reason as described in `_burn`:
// `from`'s balance is the number of token held, which is at least one before the current
// transfer.
// `_balances[to]` could overflow in the conditions described in `_mint`. That would require
// all 2**256 token ids to be minted, which in practice is impossible.
_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(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory data) private returns (bool) {
if (to.isContract()) {
try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _beforeConsecutiveTokenTransfer(address from,
address to,
uint256,
uint96 size) internal virtual {
if (from != address(0)) {
_balances[from] -= size;
}
if (to != address(0)) {
_balances[to] += size;
}
}
function _afterConsecutiveTokenTransfer(address,
address,
uint256,
uint96) internal virtual {}
uint256[44] private __gap;
}
| 16,646 | 12,996 |
e56d42ac6d308bc7d1b961334543a3bb8465dc5e081ab41238fd938f9d1deac5
| 12,972 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe1095934cae87c98494dbd5e23365107ecff9e2f.sol
| 3,278 | 11,879 |
pragma solidity ^0.4.25;
contract CryptoMinerClassic {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Classic";
string public symbol = "CMC";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 15;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 5;
uint8 constant internal refferalFee_ = 35;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 145,509 | 12,997 |
e5fe9fc65fae9cfefc447582b9b106ccce3d993b1ef49a35db6c627167fb6e7d
| 23,251 |
.sol
|
Solidity
| false |
362823574
|
BanklessDAO/bankless-contracts
|
8e2c41333e0dfb1484c1fadda829ab05a55ba770
|
src/Bank.sol
| 4,142 | 15,709 |
pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Bank {
/// @notice EIP-20 token name for this token
string public constant name = "Bankless Token";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "BANK";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 1_000_000_000e18; // 1 billion Bank
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
require(mintingAllowedAfter_ >= block.timestamp, "Bank::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "Bank::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "Bank::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "Bank::mint: minting not allowed yet");
require(dst != address(0), "Bank::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "Bank::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "Bank::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "Bank::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "Bank::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Bank::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 {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Bank::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), "Bank::permit: invalid signature");
require(signatory == owner, "Bank::permit: unauthorized");
require(now <= deadline, "Bank::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Bank::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Bank::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Bank::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Bank::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Bank::delegateBySig: invalid nonce");
require(now <= expiry, "Bank::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Bank::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Bank::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Bank::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Bank::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Bank::_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, "Bank::_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, "Bank::_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, "Bank::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 246,012 | 12,998 |
789d3d75df994206e3e532697536a7007a5a71903a452e7bc4e9fccdeed87c86
| 18,136 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x89c7785c623C54ab7f64112B04c5A3C490dB9dCD/contract.sol
| 4,826 | 17,292 |
// 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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// 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");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AuroraProtocol 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 = 'Aurora';
string private constant _SYMBOL = 'LIGHT';
uint8 private constant _DECIMALS = 9;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 20600 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 100;
uint256 private constant _BURN_FEE = 200;
uint256 private constant _MAX_TX_SIZE = 200000000 * _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 tokenFromMagnetion(_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 magnetionFromToken(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 tokenFromMagnetion(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total magnetions");
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] = tokenFromMagnetion(_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);
_magnetFee(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);
_magnetFee(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);
_magnetFee(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);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _magnetFee(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;
}
}
| 256,555 | 12,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.