contract_name
stringlengths 1
61
| file_path
stringlengths 5
50.4k
| contract_address
stringlengths 42
42
| language
stringclasses 1
value | class_name
stringlengths 1
61
| class_code
stringlengths 4
330k
| class_documentation
stringlengths 0
29.1k
| class_documentation_type
stringclasses 6
values | func_name
stringlengths 0
62
| func_code
stringlengths 1
303k
| func_documentation
stringlengths 2
14.9k
| func_documentation_type
stringclasses 4
values | compiler_version
stringlengths 15
42
| license_type
stringclasses 14
values | swarm_source
stringlengths 0
71
| meta
dict | __index_level_0__
int64 0
60.4k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vault | Vault.sol | 0x8ce610ec56ce3ad3678c426f0dfc965568db6ddc | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://1856e7c256ec8ffeca9a098693359e57ee947766cbac10a43db675a174fefa7f | {
"func_code_index": [
1647,
1726
]
} | 9,407 |
Vault | Vault.sol | 0x8ce610ec56ce3ad3678c426f0dfc965568db6ddc | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://1856e7c256ec8ffeca9a098693359e57ee947766cbac10a43db675a174fefa7f | {
"func_code_index": [
2039,
2141
]
} | 9,408 |
Vault | Vault.sol | 0x8ce610ec56ce3ad3678c426f0dfc965568db6ddc | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current 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;
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://1856e7c256ec8ffeca9a098693359e57ee947766cbac10a43db675a174fefa7f | {
"func_code_index": [
484,
568
]
} | 9,409 |
Vault | Vault.sol | 0x8ce610ec56ce3ad3678c426f0dfc965568db6ddc | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current 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;
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://1856e7c256ec8ffeca9a098693359e57ee947766cbac10a43db675a174fefa7f | {
"func_code_index": [
1124,
1277
]
} | 9,410 |
Vault | Vault.sol | 0x8ce610ec56ce3ad3678c426f0dfc965568db6ddc | Solidity | Ownable | contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current 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;
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://1856e7c256ec8ffeca9a098693359e57ee947766cbac10a43db675a174fefa7f | {
"func_code_index": [
1427,
1676
]
} | 9,411 |
Vault | Vault.sol | 0x8ce610ec56ce3ad3678c426f0dfc965568db6ddc | Solidity | Vault | contract Vault is Ownable, ReentrancyGuard {
using SafeMath for uint;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
using SafeERC20 for IERC20;
//==================== Contract Variables =======================
// Contract variables must be changed before live deployment
uint public constant LOCKUP_DURATION = 60 days;
uint public constant FEE_PERCENT_X_100 = 30;
uint public constant FEE_PERCENT_TO_BUYBACK_X_100 = 2500;
uint public constant REWARD_INTERVAL = 365 days;
uint public constant ADMIN_CAN_CLAIM_AFTER = 395 days;
uint public constant REWARD_RETURN_PERCENT_X_100 = 1500;
// ETH fee equivalent predefined gas price
uint public constant MIN_ETH_FEE_IN_WEI = 40000 * 1 * 10**9;
address public constant TRUSTED_DEPOSIT_TOKEN_ADDRESS = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
address public constant TRUSTED_CTOKEN_ADDRESS = 0xf650C3d88D12dB855b8bf7D11Be6C55A4e07dCC9;
address public constant TRUSTED_PLATFORM_TOKEN_ADDRESS = 0x961C8c0B1aaD0c0b10a51FeF6a867E3091BCef17;
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
//================= End Contract Variables ======================
uint public constant ONE_HUNDRED_X_100 = 10000;
uint public immutable contractStartTime;
constructor() public {
contractStartTime = block.timestamp;
}
IUniswapV2Router public constant uniswapRouterV2 = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
modifier noContractsAllowed() {
require(tx.origin == msg.sender, "No Contracts Allowed!");
_;
}
// ------------------- event definitions -------------------
event Deposit(address indexed account, uint amount);
event Withdraw(address indexed account, uint amount);
event EtherRewardDisbursed(uint amount);
event TokenRewardDisbursed(uint amount);
event PlatformTokenRewardClaimed(address indexed account, uint amount);
event CompoundRewardClaimed(address indexed account, uint amount);
event EtherRewardClaimed(address indexed account, uint amount);
event TokenRewardClaimed(address indexed account, uint amount);
event PlatformTokenAdded(uint amount);
// ----------------- end event definitions -----------------
EnumerableSet.AddressSet private holders;
// view functon to get number of stakers
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
// token contract address => token balance of this contract
mapping (address => uint) public tokenBalances;
// user wallet => balance
mapping (address => uint) public cTokenBalance;
mapping (address => uint) public depositTokenBalance;
mapping (address => uint) public totalTokensDepositedByUser;
mapping (address => uint) public totalTokensWithdrawnByUser;
mapping (address => uint) public totalEarnedCompoundDivs;
mapping (address => uint) public totalEarnedEthDivs;
mapping (address => uint) public totalEarnedTokenDivs;
mapping (address => uint) public totalEarnedPlatformTokenDivs;
mapping (address => uint) public depositTime;
mapping (address => uint) public lastClaimedTime;
uint public totalCTokens;
uint public totalDepositedTokens;
// -----------------
uint public constant POINT_MULTIPLIER = 1e18;
mapping (address => uint) public lastTokenDivPoints;
mapping (address => uint) public tokenDivsBalance;
uint public totalTokenDivPoints;
mapping (address => uint) public lastEthDivPoints;
mapping (address => uint) public ethDivsBalance;
uint public totalEthDivPoints;
mapping (address => uint) public platformTokenDivsBalance;
uint public totalEthDisbursed;
uint public totalTokensDisbursed;
function tokenDivsOwing(address account) public view returns (uint) {
uint newDivPoints = totalTokenDivPoints.sub(lastTokenDivPoints[account]);
return depositTokenBalance[account].mul(newDivPoints).div(POINT_MULTIPLIER);
}
function ethDivsOwing(address account) public view returns (uint) {
uint newDivPoints = totalEthDivPoints.sub(lastEthDivPoints[account]);
return depositTokenBalance[account].mul(newDivPoints).div(POINT_MULTIPLIER);
}
function distributeEthDivs(uint amount) private {
if (totalDepositedTokens == 0) return;
totalEthDivPoints = totalEthDivPoints.add(amount.mul(POINT_MULTIPLIER).div(totalDepositedTokens));
totalEthDisbursed = totalEthDisbursed.add(amount);
increaseTokenBalance(address(0), amount);
emit EtherRewardDisbursed(amount);
}
function distributeTokenDivs(uint amount) private {
if (totalDepositedTokens == 0) return;
totalTokenDivPoints = totalTokenDivPoints.add(amount.mul(POINT_MULTIPLIER).div(totalDepositedTokens));
totalTokensDisbursed = totalTokensDisbursed.add(amount);
increaseTokenBalance(TRUSTED_DEPOSIT_TOKEN_ADDRESS, amount);
emit TokenRewardDisbursed(amount);
}
// -----------------
// view function to get depositors list
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositTokenBalance[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
function updateAccount(address account) private {
// update user account here
uint tokensOwing = tokenDivsOwing(account);
lastTokenDivPoints[account] = totalTokenDivPoints;
if (tokensOwing > 0) {
tokenDivsBalance[account] = tokenDivsBalance[account].add(tokensOwing);
}
uint weiOwing = ethDivsOwing(account);
lastEthDivPoints[account] = totalEthDivPoints;
if (weiOwing > 0) {
ethDivsBalance[account] = ethDivsBalance[account].add(weiOwing);
}
uint platformTokensOwing = platformTokenDivsOwing(account);
if (platformTokensOwing > 0) {
platformTokenDivsBalance[account] = platformTokenDivsBalance[account].add(platformTokensOwing);
}
lastClaimedTime[account] = block.timestamp;
}
function platformTokenDivsOwing(address account) public view returns (uint) {
if (!holders.contains(account)) return 0;
if (depositTokenBalance[account] == 0) return 0;
uint timeDiff;
uint stakingEndTime = contractStartTime.add(REWARD_INTERVAL);
uint _now = block.timestamp;
if (_now > stakingEndTime) {
_now = stakingEndTime;
}
if (lastClaimedTime[account] >= _now) {
timeDiff = 0;
} else {
timeDiff = _now.sub(lastClaimedTime[account]);
}
uint pendingDivs = depositTokenBalance[account]
.mul(REWARD_RETURN_PERCENT_X_100)
.mul(timeDiff)
.div(REWARD_INTERVAL)
.div(ONE_HUNDRED_X_100);
return pendingDivs;
}
function getEstimatedCompoundDivsOwing(address account) public view returns (uint) {
uint convertedBalance = getConvertedBalance(cTokenBalance[account]);
uint depositedBalance = depositTokenBalance[account];
return (convertedBalance > depositedBalance ? convertedBalance.sub(depositedBalance) : 0);
}
function getConvertedBalance(uint _cTokenBalance) public view returns (uint) {
uint exchangeRateStored = getExchangeRateStored();
uint convertedBalance = _cTokenBalance.mul(exchangeRateStored).div(10**18);
return convertedBalance;
}
function _claimEthDivs() private {
updateAccount(msg.sender);
uint amount = ethDivsBalance[msg.sender];
ethDivsBalance[msg.sender] = 0;
if (amount == 0) return;
decreaseTokenBalance(address(0), amount);
msg.sender.transfer(amount);
totalEarnedEthDivs[msg.sender] = totalEarnedEthDivs[msg.sender].add(amount);
emit EtherRewardClaimed(msg.sender, amount);
}
function _claimTokenDivs() private {
updateAccount(msg.sender);
uint amount = tokenDivsBalance[msg.sender];
tokenDivsBalance[msg.sender] = 0;
if (amount == 0) return;
decreaseTokenBalance(TRUSTED_DEPOSIT_TOKEN_ADDRESS, amount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, amount);
totalEarnedTokenDivs[msg.sender] = totalEarnedTokenDivs[msg.sender].add(amount);
emit TokenRewardClaimed(msg.sender, amount);
}
function _claimCompoundDivs() private {
updateAccount(msg.sender);
uint exchangeRateCurrent = getExchangeRateCurrent();
uint convertedBalance = cTokenBalance[msg.sender].mul(exchangeRateCurrent).div(10**18);
uint depositedBalance = depositTokenBalance[msg.sender];
uint amount = convertedBalance > depositedBalance ? convertedBalance.sub(depositedBalance) : 0;
if (amount == 0) return;
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceived);
totalEarnedCompoundDivs[msg.sender] = totalEarnedCompoundDivs[msg.sender].add(depositTokenReceived);
emit CompoundRewardClaimed(msg.sender, depositTokenReceived);
}
function _claimPlatformTokenDivs(uint _amountOutMin_platformTokens) private {
updateAccount(msg.sender);
uint amount = platformTokenDivsBalance[msg.sender];
if (amount == 0) return;
address[] memory path = new address[](3);
path[0] = TRUSTED_DEPOSIT_TOKEN_ADDRESS;
path[1] = uniswapRouterV2.WETH();
path[2] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uint estimatedAmountOut = uniswapRouterV2.getAmountsOut(amount, path)[2];
require(estimatedAmountOut >= _amountOutMin_platformTokens, "_claimPlatformTokenDivs: slippage error!");
if (IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this)) < estimatedAmountOut) {
return;
}
platformTokenDivsBalance[msg.sender] = 0;
decreaseTokenBalance(TRUSTED_PLATFORM_TOKEN_ADDRESS, estimatedAmountOut);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(msg.sender, estimatedAmountOut);
totalEarnedPlatformTokenDivs[msg.sender] = totalEarnedPlatformTokenDivs[msg.sender].add(estimatedAmountOut);
emit PlatformTokenRewardClaimed(msg.sender, estimatedAmountOut);
}
function claimEthDivs() external noContractsAllowed nonReentrant {
_claimEthDivs();
}
function claimTokenDivs() external noContractsAllowed nonReentrant {
_claimTokenDivs();
}
function claimCompoundDivs() external noContractsAllowed nonReentrant {
_claimCompoundDivs();
}
function claimPlatformTokenDivs(uint _amountOutMin_platformTokens) external noContractsAllowed nonReentrant {
_claimPlatformTokenDivs(_amountOutMin_platformTokens);
}
function claim(uint _amountOutMin_platformTokens) external noContractsAllowed nonReentrant {
_claimEthDivs();
_claimTokenDivs();
_claimCompoundDivs();
_claimPlatformTokenDivs(_amountOutMin_platformTokens);
}
function getExchangeRateCurrent() public returns (uint) {
uint exchangeRateCurrent = CErc20(TRUSTED_CTOKEN_ADDRESS).exchangeRateCurrent();
return exchangeRateCurrent;
}
function getExchangeRateStored() public view returns (uint) {
uint exchangeRateStored = CErc20(TRUSTED_CTOKEN_ADDRESS).exchangeRateStored();
return exchangeRateStored;
}
function deposit(uint amount, uint _amountOutMin_ethFeeBuyBack, uint deadline) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
updateAccount(msg.sender);
// increment token balance!
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransferFrom(msg.sender, address(this), amount);
totalTokensDepositedByUser[msg.sender] = totalTokensDepositedByUser[msg.sender].add(amount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(TRUSTED_CTOKEN_ADDRESS, 0);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(TRUSTED_CTOKEN_ADDRESS, amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).mint(amount) == 0, "mint failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint cTokenReceived = newCTokenBalance.sub(oldCTokenBalance);
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].add(cTokenReceived);
totalCTokens = totalCTokens.add(cTokenReceived);
increaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenReceived);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].add(amount);
totalDepositedTokens = totalDepositedTokens.add(amount);
handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
holders.add(msg.sender);
depositTime[msg.sender] = block.timestamp;
emit Deposit(msg.sender, amount);
}
function withdraw(uint amount, uint _amountOutMin_ethFeeBuyBack, uint _amountOutMin_tokenFeeBuyBack, uint deadline) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
require(amount <= depositTokenBalance[msg.sender], "Cannot withdraw more than deposited!");
require(block.timestamp.sub(depositTime[msg.sender]) > LOCKUP_DURATION, "You recently deposited, please wait before withdrawing.");
updateAccount(msg.sender);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].sub(amount);
totalDepositedTokens = totalDepositedTokens.sub(amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
uint feeAmount = depositTokenReceived.mul(FEE_PERCENT_X_100).div(ONE_HUNDRED_X_100);
uint depositTokenReceivedAfterFee = depositTokenReceived.sub(feeAmount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceivedAfterFee);
handleFee(feeAmount, _amountOutMin_tokenFeeBuyBack, deadline);
handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
if (depositTokenBalance[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdraw(msg.sender, depositTokenReceived);
}
// emergency withdraw without interacting with uniswap
function emergencyWithdraw(uint amount) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
require(amount <= depositTokenBalance[msg.sender], "Cannot withdraw more than deposited!");
require(block.timestamp.sub(depositTime[msg.sender]) > LOCKUP_DURATION, "You recently deposited, please wait before withdrawing.");
updateAccount(msg.sender);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].sub(amount);
totalDepositedTokens = totalDepositedTokens.sub(amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
uint feeAmount = depositTokenReceived.mul(FEE_PERCENT_X_100).div(ONE_HUNDRED_X_100);
uint depositTokenReceivedAfterFee = depositTokenReceived.sub(feeAmount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceivedAfterFee);
// no uniswap interaction
// handleFee(feeAmount, _amountOutMin_tokenFeeBuyBack, deadline);
// handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
if (depositTokenBalance[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdraw(msg.sender, depositTokenReceived);
}
function handleFee(uint feeAmount, uint _amountOutMin_tokenFeeBuyBack, uint deadline) private {
uint buyBackFeeAmount = feeAmount.mul(FEE_PERCENT_TO_BUYBACK_X_100).div(ONE_HUNDRED_X_100);
uint remainingFeeAmount = feeAmount.sub(buyBackFeeAmount);
// handle distribution
distributeTokenDivs(remainingFeeAmount);
// handle buyback
// --- swap token to platform token here! ----
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(address(uniswapRouterV2), 0);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(address(uniswapRouterV2), buyBackFeeAmount);
uint oldPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
address[] memory path = new address[](3);
path[0] = TRUSTED_DEPOSIT_TOKEN_ADDRESS;
path[1] = uniswapRouterV2.WETH();
path[2] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uniswapRouterV2.swapExactTokensForTokens(buyBackFeeAmount, _amountOutMin_tokenFeeBuyBack, path, address(this), deadline);
uint newPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
uint platformTokensReceived = newPlatformTokenBalance.sub(oldPlatformTokenBalance);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(BURN_ADDRESS, platformTokensReceived);
// ---- end swap token to plaform tokens -----
}
function handleEthFee(uint feeAmount, uint _amountOutMin_ethFeeBuyBack, uint deadline) private {
require(feeAmount >= MIN_ETH_FEE_IN_WEI, "Insufficient ETH Fee!");
uint buyBackFeeAmount = feeAmount.mul(FEE_PERCENT_TO_BUYBACK_X_100).div(ONE_HUNDRED_X_100);
uint remainingFeeAmount = feeAmount.sub(buyBackFeeAmount);
// handle distribution
distributeEthDivs(remainingFeeAmount);
// handle buyback
// --- swap eth to platform token here! ----
uint oldPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
address[] memory path = new address[](2);
path[0] = uniswapRouterV2.WETH();
path[1] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uniswapRouterV2.swapExactETHForTokens{value: buyBackFeeAmount}(_amountOutMin_ethFeeBuyBack, path, address(this), deadline);
uint newPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
uint platformTokensReceived = newPlatformTokenBalance.sub(oldPlatformTokenBalance);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(BURN_ADDRESS, platformTokensReceived);
// ---- end swap eth to plaform tokens -----
}
receive () external payable {
// receive eth do nothing
}
function increaseTokenBalance(address token, uint amount) private {
tokenBalances[token] = tokenBalances[token].add(amount);
}
function decreaseTokenBalance(address token, uint amount) private {
tokenBalances[token] = tokenBalances[token].sub(amount);
}
function addPlatformTokenBalance(uint amount) external nonReentrant onlyOwner {
increaseTokenBalance(TRUSTED_PLATFORM_TOKEN_ADDRESS, amount);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransferFrom(msg.sender, address(this), amount);
emit PlatformTokenAdded(amount);
}
function claimExtraTokens(address token) external nonReentrant onlyOwner {
if (token == address(0)) {
uint ethDiff = address(this).balance.sub(tokenBalances[token]);
msg.sender.transfer(ethDiff);
return;
}
uint diff = IERC20(token).balanceOf(address(this)).sub(tokenBalances[token]);
IERC20(token).safeTransfer(msg.sender, diff);
}
function claimAnyToken(address token, uint amount) external onlyOwner {
require(now > contractStartTime.add(ADMIN_CAN_CLAIM_AFTER), "Contract not expired yet!");
if (token == address(0)) {
msg.sender.transfer(amount);
return;
}
IERC20(token).safeTransfer(msg.sender, amount);
}
} | /**
* Accounting:
* - the smart contract maintains a ledger of token balances which changes upon actions affecting
* this smart contract's token balance.
*
* - it allows owner to withdraw any extra amount of any tokens that have not been recorded,
* i.e, - any tokens that are accidentally transferred to this smart contract.
*
* - care must be taken in auditing that `claimExtraTokens` function does not allow withdrawals of
* any tokens in this smart contract in more amounts than necessary. In simple terms, admin can
* only transfer out tokens that are accidentally sent to this smart contract. Nothing more nothing less.
*/ | NatSpecMultiLine | getNumberOfHolders | function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
| // view functon to get number of stakers | LineComment | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://1856e7c256ec8ffeca9a098693359e57ee947766cbac10a43db675a174fefa7f | {
"func_code_index": [
2558,
2662
]
} | 9,412 |
Vault | Vault.sol | 0x8ce610ec56ce3ad3678c426f0dfc965568db6ddc | Solidity | Vault | contract Vault is Ownable, ReentrancyGuard {
using SafeMath for uint;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
using SafeERC20 for IERC20;
//==================== Contract Variables =======================
// Contract variables must be changed before live deployment
uint public constant LOCKUP_DURATION = 60 days;
uint public constant FEE_PERCENT_X_100 = 30;
uint public constant FEE_PERCENT_TO_BUYBACK_X_100 = 2500;
uint public constant REWARD_INTERVAL = 365 days;
uint public constant ADMIN_CAN_CLAIM_AFTER = 395 days;
uint public constant REWARD_RETURN_PERCENT_X_100 = 1500;
// ETH fee equivalent predefined gas price
uint public constant MIN_ETH_FEE_IN_WEI = 40000 * 1 * 10**9;
address public constant TRUSTED_DEPOSIT_TOKEN_ADDRESS = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
address public constant TRUSTED_CTOKEN_ADDRESS = 0xf650C3d88D12dB855b8bf7D11Be6C55A4e07dCC9;
address public constant TRUSTED_PLATFORM_TOKEN_ADDRESS = 0x961C8c0B1aaD0c0b10a51FeF6a867E3091BCef17;
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
//================= End Contract Variables ======================
uint public constant ONE_HUNDRED_X_100 = 10000;
uint public immutable contractStartTime;
constructor() public {
contractStartTime = block.timestamp;
}
IUniswapV2Router public constant uniswapRouterV2 = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
modifier noContractsAllowed() {
require(tx.origin == msg.sender, "No Contracts Allowed!");
_;
}
// ------------------- event definitions -------------------
event Deposit(address indexed account, uint amount);
event Withdraw(address indexed account, uint amount);
event EtherRewardDisbursed(uint amount);
event TokenRewardDisbursed(uint amount);
event PlatformTokenRewardClaimed(address indexed account, uint amount);
event CompoundRewardClaimed(address indexed account, uint amount);
event EtherRewardClaimed(address indexed account, uint amount);
event TokenRewardClaimed(address indexed account, uint amount);
event PlatformTokenAdded(uint amount);
// ----------------- end event definitions -----------------
EnumerableSet.AddressSet private holders;
// view functon to get number of stakers
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
// token contract address => token balance of this contract
mapping (address => uint) public tokenBalances;
// user wallet => balance
mapping (address => uint) public cTokenBalance;
mapping (address => uint) public depositTokenBalance;
mapping (address => uint) public totalTokensDepositedByUser;
mapping (address => uint) public totalTokensWithdrawnByUser;
mapping (address => uint) public totalEarnedCompoundDivs;
mapping (address => uint) public totalEarnedEthDivs;
mapping (address => uint) public totalEarnedTokenDivs;
mapping (address => uint) public totalEarnedPlatformTokenDivs;
mapping (address => uint) public depositTime;
mapping (address => uint) public lastClaimedTime;
uint public totalCTokens;
uint public totalDepositedTokens;
// -----------------
uint public constant POINT_MULTIPLIER = 1e18;
mapping (address => uint) public lastTokenDivPoints;
mapping (address => uint) public tokenDivsBalance;
uint public totalTokenDivPoints;
mapping (address => uint) public lastEthDivPoints;
mapping (address => uint) public ethDivsBalance;
uint public totalEthDivPoints;
mapping (address => uint) public platformTokenDivsBalance;
uint public totalEthDisbursed;
uint public totalTokensDisbursed;
function tokenDivsOwing(address account) public view returns (uint) {
uint newDivPoints = totalTokenDivPoints.sub(lastTokenDivPoints[account]);
return depositTokenBalance[account].mul(newDivPoints).div(POINT_MULTIPLIER);
}
function ethDivsOwing(address account) public view returns (uint) {
uint newDivPoints = totalEthDivPoints.sub(lastEthDivPoints[account]);
return depositTokenBalance[account].mul(newDivPoints).div(POINT_MULTIPLIER);
}
function distributeEthDivs(uint amount) private {
if (totalDepositedTokens == 0) return;
totalEthDivPoints = totalEthDivPoints.add(amount.mul(POINT_MULTIPLIER).div(totalDepositedTokens));
totalEthDisbursed = totalEthDisbursed.add(amount);
increaseTokenBalance(address(0), amount);
emit EtherRewardDisbursed(amount);
}
function distributeTokenDivs(uint amount) private {
if (totalDepositedTokens == 0) return;
totalTokenDivPoints = totalTokenDivPoints.add(amount.mul(POINT_MULTIPLIER).div(totalDepositedTokens));
totalTokensDisbursed = totalTokensDisbursed.add(amount);
increaseTokenBalance(TRUSTED_DEPOSIT_TOKEN_ADDRESS, amount);
emit TokenRewardDisbursed(amount);
}
// -----------------
// view function to get depositors list
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositTokenBalance[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
function updateAccount(address account) private {
// update user account here
uint tokensOwing = tokenDivsOwing(account);
lastTokenDivPoints[account] = totalTokenDivPoints;
if (tokensOwing > 0) {
tokenDivsBalance[account] = tokenDivsBalance[account].add(tokensOwing);
}
uint weiOwing = ethDivsOwing(account);
lastEthDivPoints[account] = totalEthDivPoints;
if (weiOwing > 0) {
ethDivsBalance[account] = ethDivsBalance[account].add(weiOwing);
}
uint platformTokensOwing = platformTokenDivsOwing(account);
if (platformTokensOwing > 0) {
platformTokenDivsBalance[account] = platformTokenDivsBalance[account].add(platformTokensOwing);
}
lastClaimedTime[account] = block.timestamp;
}
function platformTokenDivsOwing(address account) public view returns (uint) {
if (!holders.contains(account)) return 0;
if (depositTokenBalance[account] == 0) return 0;
uint timeDiff;
uint stakingEndTime = contractStartTime.add(REWARD_INTERVAL);
uint _now = block.timestamp;
if (_now > stakingEndTime) {
_now = stakingEndTime;
}
if (lastClaimedTime[account] >= _now) {
timeDiff = 0;
} else {
timeDiff = _now.sub(lastClaimedTime[account]);
}
uint pendingDivs = depositTokenBalance[account]
.mul(REWARD_RETURN_PERCENT_X_100)
.mul(timeDiff)
.div(REWARD_INTERVAL)
.div(ONE_HUNDRED_X_100);
return pendingDivs;
}
function getEstimatedCompoundDivsOwing(address account) public view returns (uint) {
uint convertedBalance = getConvertedBalance(cTokenBalance[account]);
uint depositedBalance = depositTokenBalance[account];
return (convertedBalance > depositedBalance ? convertedBalance.sub(depositedBalance) : 0);
}
function getConvertedBalance(uint _cTokenBalance) public view returns (uint) {
uint exchangeRateStored = getExchangeRateStored();
uint convertedBalance = _cTokenBalance.mul(exchangeRateStored).div(10**18);
return convertedBalance;
}
function _claimEthDivs() private {
updateAccount(msg.sender);
uint amount = ethDivsBalance[msg.sender];
ethDivsBalance[msg.sender] = 0;
if (amount == 0) return;
decreaseTokenBalance(address(0), amount);
msg.sender.transfer(amount);
totalEarnedEthDivs[msg.sender] = totalEarnedEthDivs[msg.sender].add(amount);
emit EtherRewardClaimed(msg.sender, amount);
}
function _claimTokenDivs() private {
updateAccount(msg.sender);
uint amount = tokenDivsBalance[msg.sender];
tokenDivsBalance[msg.sender] = 0;
if (amount == 0) return;
decreaseTokenBalance(TRUSTED_DEPOSIT_TOKEN_ADDRESS, amount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, amount);
totalEarnedTokenDivs[msg.sender] = totalEarnedTokenDivs[msg.sender].add(amount);
emit TokenRewardClaimed(msg.sender, amount);
}
function _claimCompoundDivs() private {
updateAccount(msg.sender);
uint exchangeRateCurrent = getExchangeRateCurrent();
uint convertedBalance = cTokenBalance[msg.sender].mul(exchangeRateCurrent).div(10**18);
uint depositedBalance = depositTokenBalance[msg.sender];
uint amount = convertedBalance > depositedBalance ? convertedBalance.sub(depositedBalance) : 0;
if (amount == 0) return;
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceived);
totalEarnedCompoundDivs[msg.sender] = totalEarnedCompoundDivs[msg.sender].add(depositTokenReceived);
emit CompoundRewardClaimed(msg.sender, depositTokenReceived);
}
function _claimPlatformTokenDivs(uint _amountOutMin_platformTokens) private {
updateAccount(msg.sender);
uint amount = platformTokenDivsBalance[msg.sender];
if (amount == 0) return;
address[] memory path = new address[](3);
path[0] = TRUSTED_DEPOSIT_TOKEN_ADDRESS;
path[1] = uniswapRouterV2.WETH();
path[2] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uint estimatedAmountOut = uniswapRouterV2.getAmountsOut(amount, path)[2];
require(estimatedAmountOut >= _amountOutMin_platformTokens, "_claimPlatformTokenDivs: slippage error!");
if (IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this)) < estimatedAmountOut) {
return;
}
platformTokenDivsBalance[msg.sender] = 0;
decreaseTokenBalance(TRUSTED_PLATFORM_TOKEN_ADDRESS, estimatedAmountOut);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(msg.sender, estimatedAmountOut);
totalEarnedPlatformTokenDivs[msg.sender] = totalEarnedPlatformTokenDivs[msg.sender].add(estimatedAmountOut);
emit PlatformTokenRewardClaimed(msg.sender, estimatedAmountOut);
}
function claimEthDivs() external noContractsAllowed nonReentrant {
_claimEthDivs();
}
function claimTokenDivs() external noContractsAllowed nonReentrant {
_claimTokenDivs();
}
function claimCompoundDivs() external noContractsAllowed nonReentrant {
_claimCompoundDivs();
}
function claimPlatformTokenDivs(uint _amountOutMin_platformTokens) external noContractsAllowed nonReentrant {
_claimPlatformTokenDivs(_amountOutMin_platformTokens);
}
function claim(uint _amountOutMin_platformTokens) external noContractsAllowed nonReentrant {
_claimEthDivs();
_claimTokenDivs();
_claimCompoundDivs();
_claimPlatformTokenDivs(_amountOutMin_platformTokens);
}
function getExchangeRateCurrent() public returns (uint) {
uint exchangeRateCurrent = CErc20(TRUSTED_CTOKEN_ADDRESS).exchangeRateCurrent();
return exchangeRateCurrent;
}
function getExchangeRateStored() public view returns (uint) {
uint exchangeRateStored = CErc20(TRUSTED_CTOKEN_ADDRESS).exchangeRateStored();
return exchangeRateStored;
}
function deposit(uint amount, uint _amountOutMin_ethFeeBuyBack, uint deadline) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
updateAccount(msg.sender);
// increment token balance!
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransferFrom(msg.sender, address(this), amount);
totalTokensDepositedByUser[msg.sender] = totalTokensDepositedByUser[msg.sender].add(amount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(TRUSTED_CTOKEN_ADDRESS, 0);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(TRUSTED_CTOKEN_ADDRESS, amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).mint(amount) == 0, "mint failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint cTokenReceived = newCTokenBalance.sub(oldCTokenBalance);
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].add(cTokenReceived);
totalCTokens = totalCTokens.add(cTokenReceived);
increaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenReceived);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].add(amount);
totalDepositedTokens = totalDepositedTokens.add(amount);
handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
holders.add(msg.sender);
depositTime[msg.sender] = block.timestamp;
emit Deposit(msg.sender, amount);
}
function withdraw(uint amount, uint _amountOutMin_ethFeeBuyBack, uint _amountOutMin_tokenFeeBuyBack, uint deadline) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
require(amount <= depositTokenBalance[msg.sender], "Cannot withdraw more than deposited!");
require(block.timestamp.sub(depositTime[msg.sender]) > LOCKUP_DURATION, "You recently deposited, please wait before withdrawing.");
updateAccount(msg.sender);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].sub(amount);
totalDepositedTokens = totalDepositedTokens.sub(amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
uint feeAmount = depositTokenReceived.mul(FEE_PERCENT_X_100).div(ONE_HUNDRED_X_100);
uint depositTokenReceivedAfterFee = depositTokenReceived.sub(feeAmount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceivedAfterFee);
handleFee(feeAmount, _amountOutMin_tokenFeeBuyBack, deadline);
handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
if (depositTokenBalance[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdraw(msg.sender, depositTokenReceived);
}
// emergency withdraw without interacting with uniswap
function emergencyWithdraw(uint amount) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
require(amount <= depositTokenBalance[msg.sender], "Cannot withdraw more than deposited!");
require(block.timestamp.sub(depositTime[msg.sender]) > LOCKUP_DURATION, "You recently deposited, please wait before withdrawing.");
updateAccount(msg.sender);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].sub(amount);
totalDepositedTokens = totalDepositedTokens.sub(amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
uint feeAmount = depositTokenReceived.mul(FEE_PERCENT_X_100).div(ONE_HUNDRED_X_100);
uint depositTokenReceivedAfterFee = depositTokenReceived.sub(feeAmount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceivedAfterFee);
// no uniswap interaction
// handleFee(feeAmount, _amountOutMin_tokenFeeBuyBack, deadline);
// handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
if (depositTokenBalance[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdraw(msg.sender, depositTokenReceived);
}
function handleFee(uint feeAmount, uint _amountOutMin_tokenFeeBuyBack, uint deadline) private {
uint buyBackFeeAmount = feeAmount.mul(FEE_PERCENT_TO_BUYBACK_X_100).div(ONE_HUNDRED_X_100);
uint remainingFeeAmount = feeAmount.sub(buyBackFeeAmount);
// handle distribution
distributeTokenDivs(remainingFeeAmount);
// handle buyback
// --- swap token to platform token here! ----
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(address(uniswapRouterV2), 0);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(address(uniswapRouterV2), buyBackFeeAmount);
uint oldPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
address[] memory path = new address[](3);
path[0] = TRUSTED_DEPOSIT_TOKEN_ADDRESS;
path[1] = uniswapRouterV2.WETH();
path[2] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uniswapRouterV2.swapExactTokensForTokens(buyBackFeeAmount, _amountOutMin_tokenFeeBuyBack, path, address(this), deadline);
uint newPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
uint platformTokensReceived = newPlatformTokenBalance.sub(oldPlatformTokenBalance);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(BURN_ADDRESS, platformTokensReceived);
// ---- end swap token to plaform tokens -----
}
function handleEthFee(uint feeAmount, uint _amountOutMin_ethFeeBuyBack, uint deadline) private {
require(feeAmount >= MIN_ETH_FEE_IN_WEI, "Insufficient ETH Fee!");
uint buyBackFeeAmount = feeAmount.mul(FEE_PERCENT_TO_BUYBACK_X_100).div(ONE_HUNDRED_X_100);
uint remainingFeeAmount = feeAmount.sub(buyBackFeeAmount);
// handle distribution
distributeEthDivs(remainingFeeAmount);
// handle buyback
// --- swap eth to platform token here! ----
uint oldPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
address[] memory path = new address[](2);
path[0] = uniswapRouterV2.WETH();
path[1] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uniswapRouterV2.swapExactETHForTokens{value: buyBackFeeAmount}(_amountOutMin_ethFeeBuyBack, path, address(this), deadline);
uint newPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
uint platformTokensReceived = newPlatformTokenBalance.sub(oldPlatformTokenBalance);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(BURN_ADDRESS, platformTokensReceived);
// ---- end swap eth to plaform tokens -----
}
receive () external payable {
// receive eth do nothing
}
function increaseTokenBalance(address token, uint amount) private {
tokenBalances[token] = tokenBalances[token].add(amount);
}
function decreaseTokenBalance(address token, uint amount) private {
tokenBalances[token] = tokenBalances[token].sub(amount);
}
function addPlatformTokenBalance(uint amount) external nonReentrant onlyOwner {
increaseTokenBalance(TRUSTED_PLATFORM_TOKEN_ADDRESS, amount);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransferFrom(msg.sender, address(this), amount);
emit PlatformTokenAdded(amount);
}
function claimExtraTokens(address token) external nonReentrant onlyOwner {
if (token == address(0)) {
uint ethDiff = address(this).balance.sub(tokenBalances[token]);
msg.sender.transfer(ethDiff);
return;
}
uint diff = IERC20(token).balanceOf(address(this)).sub(tokenBalances[token]);
IERC20(token).safeTransfer(msg.sender, diff);
}
function claimAnyToken(address token, uint amount) external onlyOwner {
require(now > contractStartTime.add(ADMIN_CAN_CLAIM_AFTER), "Contract not expired yet!");
if (token == address(0)) {
msg.sender.transfer(amount);
return;
}
IERC20(token).safeTransfer(msg.sender, amount);
}
} | /**
* Accounting:
* - the smart contract maintains a ledger of token balances which changes upon actions affecting
* this smart contract's token balance.
*
* - it allows owner to withdraw any extra amount of any tokens that have not been recorded,
* i.e, - any tokens that are accidentally transferred to this smart contract.
*
* - care must be taken in auditing that `claimExtraTokens` function does not allow withdrawals of
* any tokens in this smart contract in more amounts than necessary. In simple terms, admin can
* only transfer out tokens that are accidentally sent to this smart contract. Nothing more nothing less.
*/ | NatSpecMultiLine | getDepositorsList | function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositTokenBalance[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
| // -----------------
// view function to get depositors list | LineComment | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://1856e7c256ec8ffeca9a098693359e57ee947766cbac10a43db675a174fefa7f | {
"func_code_index": [
5446,
6586
]
} | 9,413 |
Vault | Vault.sol | 0x8ce610ec56ce3ad3678c426f0dfc965568db6ddc | Solidity | Vault | contract Vault is Ownable, ReentrancyGuard {
using SafeMath for uint;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
using SafeERC20 for IERC20;
//==================== Contract Variables =======================
// Contract variables must be changed before live deployment
uint public constant LOCKUP_DURATION = 60 days;
uint public constant FEE_PERCENT_X_100 = 30;
uint public constant FEE_PERCENT_TO_BUYBACK_X_100 = 2500;
uint public constant REWARD_INTERVAL = 365 days;
uint public constant ADMIN_CAN_CLAIM_AFTER = 395 days;
uint public constant REWARD_RETURN_PERCENT_X_100 = 1500;
// ETH fee equivalent predefined gas price
uint public constant MIN_ETH_FEE_IN_WEI = 40000 * 1 * 10**9;
address public constant TRUSTED_DEPOSIT_TOKEN_ADDRESS = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
address public constant TRUSTED_CTOKEN_ADDRESS = 0xf650C3d88D12dB855b8bf7D11Be6C55A4e07dCC9;
address public constant TRUSTED_PLATFORM_TOKEN_ADDRESS = 0x961C8c0B1aaD0c0b10a51FeF6a867E3091BCef17;
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
//================= End Contract Variables ======================
uint public constant ONE_HUNDRED_X_100 = 10000;
uint public immutable contractStartTime;
constructor() public {
contractStartTime = block.timestamp;
}
IUniswapV2Router public constant uniswapRouterV2 = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
modifier noContractsAllowed() {
require(tx.origin == msg.sender, "No Contracts Allowed!");
_;
}
// ------------------- event definitions -------------------
event Deposit(address indexed account, uint amount);
event Withdraw(address indexed account, uint amount);
event EtherRewardDisbursed(uint amount);
event TokenRewardDisbursed(uint amount);
event PlatformTokenRewardClaimed(address indexed account, uint amount);
event CompoundRewardClaimed(address indexed account, uint amount);
event EtherRewardClaimed(address indexed account, uint amount);
event TokenRewardClaimed(address indexed account, uint amount);
event PlatformTokenAdded(uint amount);
// ----------------- end event definitions -----------------
EnumerableSet.AddressSet private holders;
// view functon to get number of stakers
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
// token contract address => token balance of this contract
mapping (address => uint) public tokenBalances;
// user wallet => balance
mapping (address => uint) public cTokenBalance;
mapping (address => uint) public depositTokenBalance;
mapping (address => uint) public totalTokensDepositedByUser;
mapping (address => uint) public totalTokensWithdrawnByUser;
mapping (address => uint) public totalEarnedCompoundDivs;
mapping (address => uint) public totalEarnedEthDivs;
mapping (address => uint) public totalEarnedTokenDivs;
mapping (address => uint) public totalEarnedPlatformTokenDivs;
mapping (address => uint) public depositTime;
mapping (address => uint) public lastClaimedTime;
uint public totalCTokens;
uint public totalDepositedTokens;
// -----------------
uint public constant POINT_MULTIPLIER = 1e18;
mapping (address => uint) public lastTokenDivPoints;
mapping (address => uint) public tokenDivsBalance;
uint public totalTokenDivPoints;
mapping (address => uint) public lastEthDivPoints;
mapping (address => uint) public ethDivsBalance;
uint public totalEthDivPoints;
mapping (address => uint) public platformTokenDivsBalance;
uint public totalEthDisbursed;
uint public totalTokensDisbursed;
function tokenDivsOwing(address account) public view returns (uint) {
uint newDivPoints = totalTokenDivPoints.sub(lastTokenDivPoints[account]);
return depositTokenBalance[account].mul(newDivPoints).div(POINT_MULTIPLIER);
}
function ethDivsOwing(address account) public view returns (uint) {
uint newDivPoints = totalEthDivPoints.sub(lastEthDivPoints[account]);
return depositTokenBalance[account].mul(newDivPoints).div(POINT_MULTIPLIER);
}
function distributeEthDivs(uint amount) private {
if (totalDepositedTokens == 0) return;
totalEthDivPoints = totalEthDivPoints.add(amount.mul(POINT_MULTIPLIER).div(totalDepositedTokens));
totalEthDisbursed = totalEthDisbursed.add(amount);
increaseTokenBalance(address(0), amount);
emit EtherRewardDisbursed(amount);
}
function distributeTokenDivs(uint amount) private {
if (totalDepositedTokens == 0) return;
totalTokenDivPoints = totalTokenDivPoints.add(amount.mul(POINT_MULTIPLIER).div(totalDepositedTokens));
totalTokensDisbursed = totalTokensDisbursed.add(amount);
increaseTokenBalance(TRUSTED_DEPOSIT_TOKEN_ADDRESS, amount);
emit TokenRewardDisbursed(amount);
}
// -----------------
// view function to get depositors list
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositTokenBalance[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
function updateAccount(address account) private {
// update user account here
uint tokensOwing = tokenDivsOwing(account);
lastTokenDivPoints[account] = totalTokenDivPoints;
if (tokensOwing > 0) {
tokenDivsBalance[account] = tokenDivsBalance[account].add(tokensOwing);
}
uint weiOwing = ethDivsOwing(account);
lastEthDivPoints[account] = totalEthDivPoints;
if (weiOwing > 0) {
ethDivsBalance[account] = ethDivsBalance[account].add(weiOwing);
}
uint platformTokensOwing = platformTokenDivsOwing(account);
if (platformTokensOwing > 0) {
platformTokenDivsBalance[account] = platformTokenDivsBalance[account].add(platformTokensOwing);
}
lastClaimedTime[account] = block.timestamp;
}
function platformTokenDivsOwing(address account) public view returns (uint) {
if (!holders.contains(account)) return 0;
if (depositTokenBalance[account] == 0) return 0;
uint timeDiff;
uint stakingEndTime = contractStartTime.add(REWARD_INTERVAL);
uint _now = block.timestamp;
if (_now > stakingEndTime) {
_now = stakingEndTime;
}
if (lastClaimedTime[account] >= _now) {
timeDiff = 0;
} else {
timeDiff = _now.sub(lastClaimedTime[account]);
}
uint pendingDivs = depositTokenBalance[account]
.mul(REWARD_RETURN_PERCENT_X_100)
.mul(timeDiff)
.div(REWARD_INTERVAL)
.div(ONE_HUNDRED_X_100);
return pendingDivs;
}
function getEstimatedCompoundDivsOwing(address account) public view returns (uint) {
uint convertedBalance = getConvertedBalance(cTokenBalance[account]);
uint depositedBalance = depositTokenBalance[account];
return (convertedBalance > depositedBalance ? convertedBalance.sub(depositedBalance) : 0);
}
function getConvertedBalance(uint _cTokenBalance) public view returns (uint) {
uint exchangeRateStored = getExchangeRateStored();
uint convertedBalance = _cTokenBalance.mul(exchangeRateStored).div(10**18);
return convertedBalance;
}
function _claimEthDivs() private {
updateAccount(msg.sender);
uint amount = ethDivsBalance[msg.sender];
ethDivsBalance[msg.sender] = 0;
if (amount == 0) return;
decreaseTokenBalance(address(0), amount);
msg.sender.transfer(amount);
totalEarnedEthDivs[msg.sender] = totalEarnedEthDivs[msg.sender].add(amount);
emit EtherRewardClaimed(msg.sender, amount);
}
function _claimTokenDivs() private {
updateAccount(msg.sender);
uint amount = tokenDivsBalance[msg.sender];
tokenDivsBalance[msg.sender] = 0;
if (amount == 0) return;
decreaseTokenBalance(TRUSTED_DEPOSIT_TOKEN_ADDRESS, amount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, amount);
totalEarnedTokenDivs[msg.sender] = totalEarnedTokenDivs[msg.sender].add(amount);
emit TokenRewardClaimed(msg.sender, amount);
}
function _claimCompoundDivs() private {
updateAccount(msg.sender);
uint exchangeRateCurrent = getExchangeRateCurrent();
uint convertedBalance = cTokenBalance[msg.sender].mul(exchangeRateCurrent).div(10**18);
uint depositedBalance = depositTokenBalance[msg.sender];
uint amount = convertedBalance > depositedBalance ? convertedBalance.sub(depositedBalance) : 0;
if (amount == 0) return;
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceived);
totalEarnedCompoundDivs[msg.sender] = totalEarnedCompoundDivs[msg.sender].add(depositTokenReceived);
emit CompoundRewardClaimed(msg.sender, depositTokenReceived);
}
function _claimPlatformTokenDivs(uint _amountOutMin_platformTokens) private {
updateAccount(msg.sender);
uint amount = platformTokenDivsBalance[msg.sender];
if (amount == 0) return;
address[] memory path = new address[](3);
path[0] = TRUSTED_DEPOSIT_TOKEN_ADDRESS;
path[1] = uniswapRouterV2.WETH();
path[2] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uint estimatedAmountOut = uniswapRouterV2.getAmountsOut(amount, path)[2];
require(estimatedAmountOut >= _amountOutMin_platformTokens, "_claimPlatformTokenDivs: slippage error!");
if (IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this)) < estimatedAmountOut) {
return;
}
platformTokenDivsBalance[msg.sender] = 0;
decreaseTokenBalance(TRUSTED_PLATFORM_TOKEN_ADDRESS, estimatedAmountOut);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(msg.sender, estimatedAmountOut);
totalEarnedPlatformTokenDivs[msg.sender] = totalEarnedPlatformTokenDivs[msg.sender].add(estimatedAmountOut);
emit PlatformTokenRewardClaimed(msg.sender, estimatedAmountOut);
}
function claimEthDivs() external noContractsAllowed nonReentrant {
_claimEthDivs();
}
function claimTokenDivs() external noContractsAllowed nonReentrant {
_claimTokenDivs();
}
function claimCompoundDivs() external noContractsAllowed nonReentrant {
_claimCompoundDivs();
}
function claimPlatformTokenDivs(uint _amountOutMin_platformTokens) external noContractsAllowed nonReentrant {
_claimPlatformTokenDivs(_amountOutMin_platformTokens);
}
function claim(uint _amountOutMin_platformTokens) external noContractsAllowed nonReentrant {
_claimEthDivs();
_claimTokenDivs();
_claimCompoundDivs();
_claimPlatformTokenDivs(_amountOutMin_platformTokens);
}
function getExchangeRateCurrent() public returns (uint) {
uint exchangeRateCurrent = CErc20(TRUSTED_CTOKEN_ADDRESS).exchangeRateCurrent();
return exchangeRateCurrent;
}
function getExchangeRateStored() public view returns (uint) {
uint exchangeRateStored = CErc20(TRUSTED_CTOKEN_ADDRESS).exchangeRateStored();
return exchangeRateStored;
}
function deposit(uint amount, uint _amountOutMin_ethFeeBuyBack, uint deadline) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
updateAccount(msg.sender);
// increment token balance!
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransferFrom(msg.sender, address(this), amount);
totalTokensDepositedByUser[msg.sender] = totalTokensDepositedByUser[msg.sender].add(amount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(TRUSTED_CTOKEN_ADDRESS, 0);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(TRUSTED_CTOKEN_ADDRESS, amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).mint(amount) == 0, "mint failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint cTokenReceived = newCTokenBalance.sub(oldCTokenBalance);
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].add(cTokenReceived);
totalCTokens = totalCTokens.add(cTokenReceived);
increaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenReceived);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].add(amount);
totalDepositedTokens = totalDepositedTokens.add(amount);
handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
holders.add(msg.sender);
depositTime[msg.sender] = block.timestamp;
emit Deposit(msg.sender, amount);
}
function withdraw(uint amount, uint _amountOutMin_ethFeeBuyBack, uint _amountOutMin_tokenFeeBuyBack, uint deadline) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
require(amount <= depositTokenBalance[msg.sender], "Cannot withdraw more than deposited!");
require(block.timestamp.sub(depositTime[msg.sender]) > LOCKUP_DURATION, "You recently deposited, please wait before withdrawing.");
updateAccount(msg.sender);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].sub(amount);
totalDepositedTokens = totalDepositedTokens.sub(amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
uint feeAmount = depositTokenReceived.mul(FEE_PERCENT_X_100).div(ONE_HUNDRED_X_100);
uint depositTokenReceivedAfterFee = depositTokenReceived.sub(feeAmount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceivedAfterFee);
handleFee(feeAmount, _amountOutMin_tokenFeeBuyBack, deadline);
handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
if (depositTokenBalance[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdraw(msg.sender, depositTokenReceived);
}
// emergency withdraw without interacting with uniswap
function emergencyWithdraw(uint amount) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
require(amount <= depositTokenBalance[msg.sender], "Cannot withdraw more than deposited!");
require(block.timestamp.sub(depositTime[msg.sender]) > LOCKUP_DURATION, "You recently deposited, please wait before withdrawing.");
updateAccount(msg.sender);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].sub(amount);
totalDepositedTokens = totalDepositedTokens.sub(amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
uint feeAmount = depositTokenReceived.mul(FEE_PERCENT_X_100).div(ONE_HUNDRED_X_100);
uint depositTokenReceivedAfterFee = depositTokenReceived.sub(feeAmount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceivedAfterFee);
// no uniswap interaction
// handleFee(feeAmount, _amountOutMin_tokenFeeBuyBack, deadline);
// handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
if (depositTokenBalance[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdraw(msg.sender, depositTokenReceived);
}
function handleFee(uint feeAmount, uint _amountOutMin_tokenFeeBuyBack, uint deadline) private {
uint buyBackFeeAmount = feeAmount.mul(FEE_PERCENT_TO_BUYBACK_X_100).div(ONE_HUNDRED_X_100);
uint remainingFeeAmount = feeAmount.sub(buyBackFeeAmount);
// handle distribution
distributeTokenDivs(remainingFeeAmount);
// handle buyback
// --- swap token to platform token here! ----
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(address(uniswapRouterV2), 0);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeApprove(address(uniswapRouterV2), buyBackFeeAmount);
uint oldPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
address[] memory path = new address[](3);
path[0] = TRUSTED_DEPOSIT_TOKEN_ADDRESS;
path[1] = uniswapRouterV2.WETH();
path[2] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uniswapRouterV2.swapExactTokensForTokens(buyBackFeeAmount, _amountOutMin_tokenFeeBuyBack, path, address(this), deadline);
uint newPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
uint platformTokensReceived = newPlatformTokenBalance.sub(oldPlatformTokenBalance);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(BURN_ADDRESS, platformTokensReceived);
// ---- end swap token to plaform tokens -----
}
function handleEthFee(uint feeAmount, uint _amountOutMin_ethFeeBuyBack, uint deadline) private {
require(feeAmount >= MIN_ETH_FEE_IN_WEI, "Insufficient ETH Fee!");
uint buyBackFeeAmount = feeAmount.mul(FEE_PERCENT_TO_BUYBACK_X_100).div(ONE_HUNDRED_X_100);
uint remainingFeeAmount = feeAmount.sub(buyBackFeeAmount);
// handle distribution
distributeEthDivs(remainingFeeAmount);
// handle buyback
// --- swap eth to platform token here! ----
uint oldPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
address[] memory path = new address[](2);
path[0] = uniswapRouterV2.WETH();
path[1] = TRUSTED_PLATFORM_TOKEN_ADDRESS;
uniswapRouterV2.swapExactETHForTokens{value: buyBackFeeAmount}(_amountOutMin_ethFeeBuyBack, path, address(this), deadline);
uint newPlatformTokenBalance = IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).balanceOf(address(this));
uint platformTokensReceived = newPlatformTokenBalance.sub(oldPlatformTokenBalance);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransfer(BURN_ADDRESS, platformTokensReceived);
// ---- end swap eth to plaform tokens -----
}
receive () external payable {
// receive eth do nothing
}
function increaseTokenBalance(address token, uint amount) private {
tokenBalances[token] = tokenBalances[token].add(amount);
}
function decreaseTokenBalance(address token, uint amount) private {
tokenBalances[token] = tokenBalances[token].sub(amount);
}
function addPlatformTokenBalance(uint amount) external nonReentrant onlyOwner {
increaseTokenBalance(TRUSTED_PLATFORM_TOKEN_ADDRESS, amount);
IERC20(TRUSTED_PLATFORM_TOKEN_ADDRESS).safeTransferFrom(msg.sender, address(this), amount);
emit PlatformTokenAdded(amount);
}
function claimExtraTokens(address token) external nonReentrant onlyOwner {
if (token == address(0)) {
uint ethDiff = address(this).balance.sub(tokenBalances[token]);
msg.sender.transfer(ethDiff);
return;
}
uint diff = IERC20(token).balanceOf(address(this)).sub(tokenBalances[token]);
IERC20(token).safeTransfer(msg.sender, diff);
}
function claimAnyToken(address token, uint amount) external onlyOwner {
require(now > contractStartTime.add(ADMIN_CAN_CLAIM_AFTER), "Contract not expired yet!");
if (token == address(0)) {
msg.sender.transfer(amount);
return;
}
IERC20(token).safeTransfer(msg.sender, amount);
}
} | /**
* Accounting:
* - the smart contract maintains a ledger of token balances which changes upon actions affecting
* this smart contract's token balance.
*
* - it allows owner to withdraw any extra amount of any tokens that have not been recorded,
* i.e, - any tokens that are accidentally transferred to this smart contract.
*
* - care must be taken in auditing that `claimExtraTokens` function does not allow withdrawals of
* any tokens in this smart contract in more amounts than necessary. In simple terms, admin can
* only transfer out tokens that are accidentally sent to this smart contract. Nothing more nothing less.
*/ | NatSpecMultiLine | emergencyWithdraw | function emergencyWithdraw(uint amount) external noContractsAllowed nonReentrant payable {
require(amount > 0, "invalid amount!");
require(amount <= depositTokenBalance[msg.sender], "Cannot withdraw more than deposited!");
require(block.timestamp.sub(depositTime[msg.sender]) > LOCKUP_DURATION, "You recently deposited, please wait before withdrawing.");
updateAccount(msg.sender);
depositTokenBalance[msg.sender] = depositTokenBalance[msg.sender].sub(amount);
totalDepositedTokens = totalDepositedTokens.sub(amount);
uint oldCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint oldDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
require(CErc20(TRUSTED_CTOKEN_ADDRESS).redeemUnderlying(amount) == 0, "redeemUnderlying failed!");
uint newCTokenBalance = IERC20(TRUSTED_CTOKEN_ADDRESS).balanceOf(address(this));
uint newDepositTokenBalance = IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).balanceOf(address(this));
uint depositTokenReceived = newDepositTokenBalance.sub(oldDepositTokenBalance);
uint cTokenRedeemed = oldCTokenBalance.sub(newCTokenBalance);
require(cTokenRedeemed <= cTokenBalance[msg.sender], "redeem exceeds balance!");
cTokenBalance[msg.sender] = cTokenBalance[msg.sender].sub(cTokenRedeemed);
totalCTokens = totalCTokens.sub(cTokenRedeemed);
decreaseTokenBalance(TRUSTED_CTOKEN_ADDRESS, cTokenRedeemed);
totalTokensWithdrawnByUser[msg.sender] = totalTokensWithdrawnByUser[msg.sender].add(depositTokenReceived);
uint feeAmount = depositTokenReceived.mul(FEE_PERCENT_X_100).div(ONE_HUNDRED_X_100);
uint depositTokenReceivedAfterFee = depositTokenReceived.sub(feeAmount);
IERC20(TRUSTED_DEPOSIT_TOKEN_ADDRESS).safeTransfer(msg.sender, depositTokenReceivedAfterFee);
// no uniswap interaction
// handleFee(feeAmount, _amountOutMin_tokenFeeBuyBack, deadline);
// handleEthFee(msg.value, _amountOutMin_ethFeeBuyBack, deadline);
if (depositTokenBalance[msg.sender] == 0) {
holders.remove(msg.sender);
}
emit Withdraw(msg.sender, depositTokenReceived);
}
| // emergency withdraw without interacting with uniswap | LineComment | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://1856e7c256ec8ffeca9a098693359e57ee947766cbac10a43db675a174fefa7f | {
"func_code_index": [
18471,
20865
]
} | 9,414 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | Module | interface Module {
/**
* @dev Inits a module for a wallet by e.g. setting some wallet specific parameters in storage.
* @param _wallet The wallet.
*/
function init(BaseWallet _wallet) external;
/**
* @dev Adds a module to a wallet.
* @param _wallet The target wallet.
* @param _module The modules to authorise.
*/
function addModule(BaseWallet _wallet, Module _module) external;
/**
* @dev Utility method to recover any ERC20 token that was sent to the
* module by mistake.
* @param _token The token to recover.
*/
function recoverToken(address _token) external;
} | /**
* @title Module
* @dev Interface for a module.
* A module MUST implement the addModule() method to ensure that a wallet with at least one module
* can never end up in a "frozen" state.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | init | function init(BaseWallet _wallet) external;
| /**
* @dev Inits a module for a wallet by e.g. setting some wallet specific parameters in storage.
* @param _wallet The wallet.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
176,
224
]
} | 9,415 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | Module | interface Module {
/**
* @dev Inits a module for a wallet by e.g. setting some wallet specific parameters in storage.
* @param _wallet The wallet.
*/
function init(BaseWallet _wallet) external;
/**
* @dev Adds a module to a wallet.
* @param _wallet The target wallet.
* @param _module The modules to authorise.
*/
function addModule(BaseWallet _wallet, Module _module) external;
/**
* @dev Utility method to recover any ERC20 token that was sent to the
* module by mistake.
* @param _token The token to recover.
*/
function recoverToken(address _token) external;
} | /**
* @title Module
* @dev Interface for a module.
* A module MUST implement the addModule() method to ensure that a wallet with at least one module
* can never end up in a "frozen" state.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | addModule | function addModule(BaseWallet _wallet, Module _module) external;
| /**
* @dev Adds a module to a wallet.
* @param _wallet The target wallet.
* @param _module The modules to authorise.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
376,
445
]
} | 9,416 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | Module | interface Module {
/**
* @dev Inits a module for a wallet by e.g. setting some wallet specific parameters in storage.
* @param _wallet The wallet.
*/
function init(BaseWallet _wallet) external;
/**
* @dev Adds a module to a wallet.
* @param _wallet The target wallet.
* @param _module The modules to authorise.
*/
function addModule(BaseWallet _wallet, Module _module) external;
/**
* @dev Utility method to recover any ERC20 token that was sent to the
* module by mistake.
* @param _token The token to recover.
*/
function recoverToken(address _token) external;
} | /**
* @title Module
* @dev Interface for a module.
* A module MUST implement the addModule() method to ensure that a wallet with at least one module
* can never end up in a "frozen" state.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | recoverToken | function recoverToken(address _token) external;
| /**
* @dev Utility method to recover any ERC20 token that was sent to the
* module by mistake.
* @param _token The token to recover.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
609,
661
]
} | 9,417 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | BaseWallet | contract BaseWallet {
// The implementation of the proxy
address public implementation;
// The owner
address public owner;
// The authorised modules
mapping (address => bool) public authorised;
// The enabled static calls
mapping (bytes4 => address) public enabled;
// The number of modules
uint public modules;
event AuthorisedModule(address indexed module, bool value);
event EnabledStaticCall(address indexed module, bytes4 indexed method);
event Invoked(address indexed module, address indexed target, uint indexed value, bytes data);
event Received(uint indexed value, address indexed sender, bytes data);
event OwnerChanged(address owner);
/**
* @dev Throws if the sender is not an authorised module.
*/
modifier moduleOnly {
require(authorised[msg.sender], "BW: msg.sender not an authorized module");
_;
}
/**
* @dev Inits the wallet by setting the owner and authorising a list of modules.
* @param _owner The owner.
* @param _modules The modules to authorise.
*/
function init(address _owner, address[] calldata _modules) external {
require(owner == address(0) && modules == 0, "BW: wallet already initialised");
require(_modules.length > 0, "BW: construction requires at least 1 module");
owner = _owner;
modules = _modules.length;
for (uint256 i = 0; i < _modules.length; i++) {
require(authorised[_modules[i]] == false, "BW: module is already added");
authorised[_modules[i]] = true;
Module(_modules[i]).init(this);
emit AuthorisedModule(_modules[i], true);
}
if (address(this).balance > 0) {
emit Received(address(this).balance, address(0), "");
}
}
/**
* @dev Enables/Disables a module.
* @param _module The target module.
* @param _value Set to true to authorise the module.
*/
function authoriseModule(address _module, bool _value) external moduleOnly {
if (authorised[_module] != _value) {
emit AuthorisedModule(_module, _value);
if (_value == true) {
modules += 1;
authorised[_module] = true;
Module(_module).init(this);
} else {
modules -= 1;
require(modules > 0, "BW: wallet must have at least one module");
delete authorised[_module];
}
}
}
/**
* @dev Enables a static method by specifying the target module to which the call
* must be delegated.
* @param _module The target module.
* @param _method The static method signature.
*/
function enableStaticCall(address _module, bytes4 _method) external moduleOnly {
require(authorised[_module], "BW: must be an authorised module for static call");
enabled[_method] = _module;
emit EnabledStaticCall(_module, _method);
}
/**
* @dev Sets a new owner for the wallet.
* @param _newOwner The new owner.
*/
function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
}
/**
* @dev Performs a generic transaction.
* @param _target The address for the transaction.
* @param _value The value of the transaction.
* @param _data The data of the transaction.
*/
function invoke(address _target, uint _value, bytes calldata _data) external moduleOnly returns (bytes memory _result) {
bool success;
// solium-disable-next-line security/no-call-value
(success, _result) = _target.call.value(_value)(_data);
if (!success) {
// solium-disable-next-line security/no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize)
revert(0, returndatasize)
}
}
emit Invoked(msg.sender, _target, _value, _data);
}
/**
* @dev This method makes it possible for the wallet to comply to interfaces expecting the wallet to
* implement specific static methods. It delegates the static call to a target contract if the data corresponds
* to an enabled method, or logs the call otherwise.
*/
function() external payable {
if (msg.data.length > 0) {
address module = enabled[msg.sig];
if (module == address(0)) {
emit Received(msg.value, msg.sender, msg.data);
} else {
require(authorised[module], "BW: must be an authorised module for static call");
// solium-disable-next-line security/no-inline-assembly
assembly {
calldatacopy(0, 0, calldatasize())
let result := staticcall(gas, module, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {revert(0, returndatasize())}
default {return (0, returndatasize())}
}
}
}
}
} | /**
* @title BaseWallet
* @dev Simple modular wallet that authorises modules to call its invoke() method.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | init | function init(address _owner, address[] calldata _modules) external {
require(owner == address(0) && modules == 0, "BW: wallet already initialised");
require(_modules.length > 0, "BW: construction requires at least 1 module");
owner = _owner;
modules = _modules.length;
for (uint256 i = 0; i < _modules.length; i++) {
require(authorised[_modules[i]] == false, "BW: module is already added");
authorised[_modules[i]] = true;
Module(_modules[i]).init(this);
emit AuthorisedModule(_modules[i], true);
}
if (address(this).balance > 0) {
emit Received(address(this).balance, address(0), "");
}
}
| /**
* @dev Inits the wallet by setting the owner and authorising a list of modules.
* @param _owner The owner.
* @param _modules The modules to authorise.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
1129,
1866
]
} | 9,418 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | BaseWallet | contract BaseWallet {
// The implementation of the proxy
address public implementation;
// The owner
address public owner;
// The authorised modules
mapping (address => bool) public authorised;
// The enabled static calls
mapping (bytes4 => address) public enabled;
// The number of modules
uint public modules;
event AuthorisedModule(address indexed module, bool value);
event EnabledStaticCall(address indexed module, bytes4 indexed method);
event Invoked(address indexed module, address indexed target, uint indexed value, bytes data);
event Received(uint indexed value, address indexed sender, bytes data);
event OwnerChanged(address owner);
/**
* @dev Throws if the sender is not an authorised module.
*/
modifier moduleOnly {
require(authorised[msg.sender], "BW: msg.sender not an authorized module");
_;
}
/**
* @dev Inits the wallet by setting the owner and authorising a list of modules.
* @param _owner The owner.
* @param _modules The modules to authorise.
*/
function init(address _owner, address[] calldata _modules) external {
require(owner == address(0) && modules == 0, "BW: wallet already initialised");
require(_modules.length > 0, "BW: construction requires at least 1 module");
owner = _owner;
modules = _modules.length;
for (uint256 i = 0; i < _modules.length; i++) {
require(authorised[_modules[i]] == false, "BW: module is already added");
authorised[_modules[i]] = true;
Module(_modules[i]).init(this);
emit AuthorisedModule(_modules[i], true);
}
if (address(this).balance > 0) {
emit Received(address(this).balance, address(0), "");
}
}
/**
* @dev Enables/Disables a module.
* @param _module The target module.
* @param _value Set to true to authorise the module.
*/
function authoriseModule(address _module, bool _value) external moduleOnly {
if (authorised[_module] != _value) {
emit AuthorisedModule(_module, _value);
if (_value == true) {
modules += 1;
authorised[_module] = true;
Module(_module).init(this);
} else {
modules -= 1;
require(modules > 0, "BW: wallet must have at least one module");
delete authorised[_module];
}
}
}
/**
* @dev Enables a static method by specifying the target module to which the call
* must be delegated.
* @param _module The target module.
* @param _method The static method signature.
*/
function enableStaticCall(address _module, bytes4 _method) external moduleOnly {
require(authorised[_module], "BW: must be an authorised module for static call");
enabled[_method] = _module;
emit EnabledStaticCall(_module, _method);
}
/**
* @dev Sets a new owner for the wallet.
* @param _newOwner The new owner.
*/
function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
}
/**
* @dev Performs a generic transaction.
* @param _target The address for the transaction.
* @param _value The value of the transaction.
* @param _data The data of the transaction.
*/
function invoke(address _target, uint _value, bytes calldata _data) external moduleOnly returns (bytes memory _result) {
bool success;
// solium-disable-next-line security/no-call-value
(success, _result) = _target.call.value(_value)(_data);
if (!success) {
// solium-disable-next-line security/no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize)
revert(0, returndatasize)
}
}
emit Invoked(msg.sender, _target, _value, _data);
}
/**
* @dev This method makes it possible for the wallet to comply to interfaces expecting the wallet to
* implement specific static methods. It delegates the static call to a target contract if the data corresponds
* to an enabled method, or logs the call otherwise.
*/
function() external payable {
if (msg.data.length > 0) {
address module = enabled[msg.sig];
if (module == address(0)) {
emit Received(msg.value, msg.sender, msg.data);
} else {
require(authorised[module], "BW: must be an authorised module for static call");
// solium-disable-next-line security/no-inline-assembly
assembly {
calldatacopy(0, 0, calldatasize())
let result := staticcall(gas, module, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {revert(0, returndatasize())}
default {return (0, returndatasize())}
}
}
}
}
} | /**
* @title BaseWallet
* @dev Simple modular wallet that authorises modules to call its invoke() method.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | authoriseModule | function authoriseModule(address _module, bool _value) external moduleOnly {
if (authorised[_module] != _value) {
emit AuthorisedModule(_module, _value);
if (_value == true) {
modules += 1;
authorised[_module] = true;
Module(_module).init(this);
} else {
modules -= 1;
require(modules > 0, "BW: wallet must have at least one module");
delete authorised[_module];
}
}
}
| /**
* @dev Enables/Disables a module.
* @param _module The target module.
* @param _value Set to true to authorise the module.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
2028,
2578
]
} | 9,419 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | BaseWallet | contract BaseWallet {
// The implementation of the proxy
address public implementation;
// The owner
address public owner;
// The authorised modules
mapping (address => bool) public authorised;
// The enabled static calls
mapping (bytes4 => address) public enabled;
// The number of modules
uint public modules;
event AuthorisedModule(address indexed module, bool value);
event EnabledStaticCall(address indexed module, bytes4 indexed method);
event Invoked(address indexed module, address indexed target, uint indexed value, bytes data);
event Received(uint indexed value, address indexed sender, bytes data);
event OwnerChanged(address owner);
/**
* @dev Throws if the sender is not an authorised module.
*/
modifier moduleOnly {
require(authorised[msg.sender], "BW: msg.sender not an authorized module");
_;
}
/**
* @dev Inits the wallet by setting the owner and authorising a list of modules.
* @param _owner The owner.
* @param _modules The modules to authorise.
*/
function init(address _owner, address[] calldata _modules) external {
require(owner == address(0) && modules == 0, "BW: wallet already initialised");
require(_modules.length > 0, "BW: construction requires at least 1 module");
owner = _owner;
modules = _modules.length;
for (uint256 i = 0; i < _modules.length; i++) {
require(authorised[_modules[i]] == false, "BW: module is already added");
authorised[_modules[i]] = true;
Module(_modules[i]).init(this);
emit AuthorisedModule(_modules[i], true);
}
if (address(this).balance > 0) {
emit Received(address(this).balance, address(0), "");
}
}
/**
* @dev Enables/Disables a module.
* @param _module The target module.
* @param _value Set to true to authorise the module.
*/
function authoriseModule(address _module, bool _value) external moduleOnly {
if (authorised[_module] != _value) {
emit AuthorisedModule(_module, _value);
if (_value == true) {
modules += 1;
authorised[_module] = true;
Module(_module).init(this);
} else {
modules -= 1;
require(modules > 0, "BW: wallet must have at least one module");
delete authorised[_module];
}
}
}
/**
* @dev Enables a static method by specifying the target module to which the call
* must be delegated.
* @param _module The target module.
* @param _method The static method signature.
*/
function enableStaticCall(address _module, bytes4 _method) external moduleOnly {
require(authorised[_module], "BW: must be an authorised module for static call");
enabled[_method] = _module;
emit EnabledStaticCall(_module, _method);
}
/**
* @dev Sets a new owner for the wallet.
* @param _newOwner The new owner.
*/
function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
}
/**
* @dev Performs a generic transaction.
* @param _target The address for the transaction.
* @param _value The value of the transaction.
* @param _data The data of the transaction.
*/
function invoke(address _target, uint _value, bytes calldata _data) external moduleOnly returns (bytes memory _result) {
bool success;
// solium-disable-next-line security/no-call-value
(success, _result) = _target.call.value(_value)(_data);
if (!success) {
// solium-disable-next-line security/no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize)
revert(0, returndatasize)
}
}
emit Invoked(msg.sender, _target, _value, _data);
}
/**
* @dev This method makes it possible for the wallet to comply to interfaces expecting the wallet to
* implement specific static methods. It delegates the static call to a target contract if the data corresponds
* to an enabled method, or logs the call otherwise.
*/
function() external payable {
if (msg.data.length > 0) {
address module = enabled[msg.sig];
if (module == address(0)) {
emit Received(msg.value, msg.sender, msg.data);
} else {
require(authorised[module], "BW: must be an authorised module for static call");
// solium-disable-next-line security/no-inline-assembly
assembly {
calldatacopy(0, 0, calldatasize())
let result := staticcall(gas, module, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {revert(0, returndatasize())}
default {return (0, returndatasize())}
}
}
}
}
} | /**
* @title BaseWallet
* @dev Simple modular wallet that authorises modules to call its invoke() method.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | enableStaticCall | function enableStaticCall(address _module, bytes4 _method) external moduleOnly {
require(authorised[_module], "BW: must be an authorised module for static call");
enabled[_method] = _module;
emit EnabledStaticCall(_module, _method);
}
| /**
* @dev Enables a static method by specifying the target module to which the call
* must be delegated.
* @param _module The target module.
* @param _method The static method signature.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
2802,
3073
]
} | 9,420 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | BaseWallet | contract BaseWallet {
// The implementation of the proxy
address public implementation;
// The owner
address public owner;
// The authorised modules
mapping (address => bool) public authorised;
// The enabled static calls
mapping (bytes4 => address) public enabled;
// The number of modules
uint public modules;
event AuthorisedModule(address indexed module, bool value);
event EnabledStaticCall(address indexed module, bytes4 indexed method);
event Invoked(address indexed module, address indexed target, uint indexed value, bytes data);
event Received(uint indexed value, address indexed sender, bytes data);
event OwnerChanged(address owner);
/**
* @dev Throws if the sender is not an authorised module.
*/
modifier moduleOnly {
require(authorised[msg.sender], "BW: msg.sender not an authorized module");
_;
}
/**
* @dev Inits the wallet by setting the owner and authorising a list of modules.
* @param _owner The owner.
* @param _modules The modules to authorise.
*/
function init(address _owner, address[] calldata _modules) external {
require(owner == address(0) && modules == 0, "BW: wallet already initialised");
require(_modules.length > 0, "BW: construction requires at least 1 module");
owner = _owner;
modules = _modules.length;
for (uint256 i = 0; i < _modules.length; i++) {
require(authorised[_modules[i]] == false, "BW: module is already added");
authorised[_modules[i]] = true;
Module(_modules[i]).init(this);
emit AuthorisedModule(_modules[i], true);
}
if (address(this).balance > 0) {
emit Received(address(this).balance, address(0), "");
}
}
/**
* @dev Enables/Disables a module.
* @param _module The target module.
* @param _value Set to true to authorise the module.
*/
function authoriseModule(address _module, bool _value) external moduleOnly {
if (authorised[_module] != _value) {
emit AuthorisedModule(_module, _value);
if (_value == true) {
modules += 1;
authorised[_module] = true;
Module(_module).init(this);
} else {
modules -= 1;
require(modules > 0, "BW: wallet must have at least one module");
delete authorised[_module];
}
}
}
/**
* @dev Enables a static method by specifying the target module to which the call
* must be delegated.
* @param _module The target module.
* @param _method The static method signature.
*/
function enableStaticCall(address _module, bytes4 _method) external moduleOnly {
require(authorised[_module], "BW: must be an authorised module for static call");
enabled[_method] = _module;
emit EnabledStaticCall(_module, _method);
}
/**
* @dev Sets a new owner for the wallet.
* @param _newOwner The new owner.
*/
function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
}
/**
* @dev Performs a generic transaction.
* @param _target The address for the transaction.
* @param _value The value of the transaction.
* @param _data The data of the transaction.
*/
function invoke(address _target, uint _value, bytes calldata _data) external moduleOnly returns (bytes memory _result) {
bool success;
// solium-disable-next-line security/no-call-value
(success, _result) = _target.call.value(_value)(_data);
if (!success) {
// solium-disable-next-line security/no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize)
revert(0, returndatasize)
}
}
emit Invoked(msg.sender, _target, _value, _data);
}
/**
* @dev This method makes it possible for the wallet to comply to interfaces expecting the wallet to
* implement specific static methods. It delegates the static call to a target contract if the data corresponds
* to an enabled method, or logs the call otherwise.
*/
function() external payable {
if (msg.data.length > 0) {
address module = enabled[msg.sig];
if (module == address(0)) {
emit Received(msg.value, msg.sender, msg.data);
} else {
require(authorised[module], "BW: must be an authorised module for static call");
// solium-disable-next-line security/no-inline-assembly
assembly {
calldatacopy(0, 0, calldatasize())
let result := staticcall(gas, module, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {revert(0, returndatasize())}
default {return (0, returndatasize())}
}
}
}
}
} | /**
* @title BaseWallet
* @dev Simple modular wallet that authorises modules to call its invoke() method.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | setOwner | function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
}
| /**
* @dev Sets a new owner for the wallet.
* @param _newOwner The new owner.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
3180,
3390
]
} | 9,421 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | BaseWallet | contract BaseWallet {
// The implementation of the proxy
address public implementation;
// The owner
address public owner;
// The authorised modules
mapping (address => bool) public authorised;
// The enabled static calls
mapping (bytes4 => address) public enabled;
// The number of modules
uint public modules;
event AuthorisedModule(address indexed module, bool value);
event EnabledStaticCall(address indexed module, bytes4 indexed method);
event Invoked(address indexed module, address indexed target, uint indexed value, bytes data);
event Received(uint indexed value, address indexed sender, bytes data);
event OwnerChanged(address owner);
/**
* @dev Throws if the sender is not an authorised module.
*/
modifier moduleOnly {
require(authorised[msg.sender], "BW: msg.sender not an authorized module");
_;
}
/**
* @dev Inits the wallet by setting the owner and authorising a list of modules.
* @param _owner The owner.
* @param _modules The modules to authorise.
*/
function init(address _owner, address[] calldata _modules) external {
require(owner == address(0) && modules == 0, "BW: wallet already initialised");
require(_modules.length > 0, "BW: construction requires at least 1 module");
owner = _owner;
modules = _modules.length;
for (uint256 i = 0; i < _modules.length; i++) {
require(authorised[_modules[i]] == false, "BW: module is already added");
authorised[_modules[i]] = true;
Module(_modules[i]).init(this);
emit AuthorisedModule(_modules[i], true);
}
if (address(this).balance > 0) {
emit Received(address(this).balance, address(0), "");
}
}
/**
* @dev Enables/Disables a module.
* @param _module The target module.
* @param _value Set to true to authorise the module.
*/
function authoriseModule(address _module, bool _value) external moduleOnly {
if (authorised[_module] != _value) {
emit AuthorisedModule(_module, _value);
if (_value == true) {
modules += 1;
authorised[_module] = true;
Module(_module).init(this);
} else {
modules -= 1;
require(modules > 0, "BW: wallet must have at least one module");
delete authorised[_module];
}
}
}
/**
* @dev Enables a static method by specifying the target module to which the call
* must be delegated.
* @param _module The target module.
* @param _method The static method signature.
*/
function enableStaticCall(address _module, bytes4 _method) external moduleOnly {
require(authorised[_module], "BW: must be an authorised module for static call");
enabled[_method] = _module;
emit EnabledStaticCall(_module, _method);
}
/**
* @dev Sets a new owner for the wallet.
* @param _newOwner The new owner.
*/
function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
}
/**
* @dev Performs a generic transaction.
* @param _target The address for the transaction.
* @param _value The value of the transaction.
* @param _data The data of the transaction.
*/
function invoke(address _target, uint _value, bytes calldata _data) external moduleOnly returns (bytes memory _result) {
bool success;
// solium-disable-next-line security/no-call-value
(success, _result) = _target.call.value(_value)(_data);
if (!success) {
// solium-disable-next-line security/no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize)
revert(0, returndatasize)
}
}
emit Invoked(msg.sender, _target, _value, _data);
}
/**
* @dev This method makes it possible for the wallet to comply to interfaces expecting the wallet to
* implement specific static methods. It delegates the static call to a target contract if the data corresponds
* to an enabled method, or logs the call otherwise.
*/
function() external payable {
if (msg.data.length > 0) {
address module = enabled[msg.sig];
if (module == address(0)) {
emit Received(msg.value, msg.sender, msg.data);
} else {
require(authorised[module], "BW: must be an authorised module for static call");
// solium-disable-next-line security/no-inline-assembly
assembly {
calldatacopy(0, 0, calldatasize())
let result := staticcall(gas, module, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {revert(0, returndatasize())}
default {return (0, returndatasize())}
}
}
}
}
} | /**
* @title BaseWallet
* @dev Simple modular wallet that authorises modules to call its invoke() method.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | invoke | function invoke(address _target, uint _value, bytes calldata _data) external moduleOnly returns (bytes memory _result) {
bool success;
// solium-disable-next-line security/no-call-value
(success, _result) = _target.call.value(_value)(_data);
if (!success) {
// solium-disable-next-line security/no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize)
revert(0, returndatasize)
}
}
emit Invoked(msg.sender, _target, _value, _data);
}
| /**
* @dev Performs a generic transaction.
* @param _target The address for the transaction.
* @param _value The value of the transaction.
* @param _data The data of the transaction.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
3614,
4194
]
} | 9,422 |
BaseWallet | BaseWallet.sol | 0xb6d64221451edbac7736d4c3da7fc827457dec03 | Solidity | BaseWallet | contract BaseWallet {
// The implementation of the proxy
address public implementation;
// The owner
address public owner;
// The authorised modules
mapping (address => bool) public authorised;
// The enabled static calls
mapping (bytes4 => address) public enabled;
// The number of modules
uint public modules;
event AuthorisedModule(address indexed module, bool value);
event EnabledStaticCall(address indexed module, bytes4 indexed method);
event Invoked(address indexed module, address indexed target, uint indexed value, bytes data);
event Received(uint indexed value, address indexed sender, bytes data);
event OwnerChanged(address owner);
/**
* @dev Throws if the sender is not an authorised module.
*/
modifier moduleOnly {
require(authorised[msg.sender], "BW: msg.sender not an authorized module");
_;
}
/**
* @dev Inits the wallet by setting the owner and authorising a list of modules.
* @param _owner The owner.
* @param _modules The modules to authorise.
*/
function init(address _owner, address[] calldata _modules) external {
require(owner == address(0) && modules == 0, "BW: wallet already initialised");
require(_modules.length > 0, "BW: construction requires at least 1 module");
owner = _owner;
modules = _modules.length;
for (uint256 i = 0; i < _modules.length; i++) {
require(authorised[_modules[i]] == false, "BW: module is already added");
authorised[_modules[i]] = true;
Module(_modules[i]).init(this);
emit AuthorisedModule(_modules[i], true);
}
if (address(this).balance > 0) {
emit Received(address(this).balance, address(0), "");
}
}
/**
* @dev Enables/Disables a module.
* @param _module The target module.
* @param _value Set to true to authorise the module.
*/
function authoriseModule(address _module, bool _value) external moduleOnly {
if (authorised[_module] != _value) {
emit AuthorisedModule(_module, _value);
if (_value == true) {
modules += 1;
authorised[_module] = true;
Module(_module).init(this);
} else {
modules -= 1;
require(modules > 0, "BW: wallet must have at least one module");
delete authorised[_module];
}
}
}
/**
* @dev Enables a static method by specifying the target module to which the call
* must be delegated.
* @param _module The target module.
* @param _method The static method signature.
*/
function enableStaticCall(address _module, bytes4 _method) external moduleOnly {
require(authorised[_module], "BW: must be an authorised module for static call");
enabled[_method] = _module;
emit EnabledStaticCall(_module, _method);
}
/**
* @dev Sets a new owner for the wallet.
* @param _newOwner The new owner.
*/
function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
}
/**
* @dev Performs a generic transaction.
* @param _target The address for the transaction.
* @param _value The value of the transaction.
* @param _data The data of the transaction.
*/
function invoke(address _target, uint _value, bytes calldata _data) external moduleOnly returns (bytes memory _result) {
bool success;
// solium-disable-next-line security/no-call-value
(success, _result) = _target.call.value(_value)(_data);
if (!success) {
// solium-disable-next-line security/no-inline-assembly
assembly {
returndatacopy(0, 0, returndatasize)
revert(0, returndatasize)
}
}
emit Invoked(msg.sender, _target, _value, _data);
}
/**
* @dev This method makes it possible for the wallet to comply to interfaces expecting the wallet to
* implement specific static methods. It delegates the static call to a target contract if the data corresponds
* to an enabled method, or logs the call otherwise.
*/
function() external payable {
if (msg.data.length > 0) {
address module = enabled[msg.sig];
if (module == address(0)) {
emit Received(msg.value, msg.sender, msg.data);
} else {
require(authorised[module], "BW: must be an authorised module for static call");
// solium-disable-next-line security/no-inline-assembly
assembly {
calldatacopy(0, 0, calldatasize())
let result := staticcall(gas, module, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {revert(0, returndatasize())}
default {return (0, returndatasize())}
}
}
}
}
} | /**
* @title BaseWallet
* @dev Simple modular wallet that authorises modules to call its invoke() method.
* @author Julien Niset - <[email protected]>
*/ | NatSpecMultiLine | function() external payable {
if (msg.data.length > 0) {
address module = enabled[msg.sig];
if (module == address(0)) {
emit Received(msg.value, msg.sender, msg.data);
} else {
require(authorised[module], "BW: must be an authorised module for static call");
// solium-disable-next-line security/no-inline-assembly
assembly {
calldatacopy(0, 0, calldatasize())
let result := staticcall(gas, module, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {revert(0, returndatasize())}
default {return (0, returndatasize())}
}
}
}
}
| /**
* @dev This method makes it possible for the wallet to comply to interfaces expecting the wallet to
* implement specific static methods. It delegates the static call to a target contract if the data corresponds
* to an enabled method, or logs the call otherwise.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://b006dfbc2c336045fc14f05576b37e93870a076202db4360484f2efd240c1851 | {
"func_code_index": [
4496,
5346
]
} | 9,423 |
|
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | EesToken | function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
| // ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
485,
1066
]
} | 9,424 |
|||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | totalSupply | function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
| // ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
1254,
1375
]
} | 9,425 |
|||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | balanceOf | function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
| // ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
1597,
1726
]
} | 9,426 |
|||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | transfer | function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
| // ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
2072,
2339
]
} | 9,427 |
|||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | approve | function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
| // ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
2851,
3059
]
} | 9,428 |
|||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | transferFrom | function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
| // ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
3598,
3941
]
} | 9,429 |
|||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | allowance | function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
| // ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
4224,
4380
]
} | 9,430 |
|||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | approveAndCall | function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
| // ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
4743,
5060
]
} | 9,431 |
|||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | function () public payable {
revert();
}
| // ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
5252,
5311
]
} | 9,432 |
||||
EesToken | EesToken.sol | 0x626a14ec8bb0d92692ef704f19968c20727dede1 | Solidity | EesToken | contract EesToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals = 18;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function EesToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
_totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[owner] = _totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | transferAnyERC20Token | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
| // ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://80b0d570ccf7886d7732cac2d4f26c90e0205f69ed962469d1825d16aa6fd985 | {
"func_code_index": [
5544,
5733
]
} | 9,433 |
|||
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
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;
}
/**
* @dev 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;
}
/**
* @dev 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;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
} | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | mul | 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;
}
| /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
89,
266
]
} | 9,434 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
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;
}
/**
* @dev 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;
}
/**
* @dev 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;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
} | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | div | 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;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
350,
630
]
} | 9,435 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
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;
}
/**
* @dev 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;
}
/**
* @dev 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;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
} | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
744,
860
]
} | 9,436 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
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;
}
/**
* @dev 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;
}
/**
* @dev 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;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
} | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
924,
1054
]
} | 9,437 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
} | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | Ownable | function Ownable() public {
owner = msg.sender;
}
| /**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
261,
321
]
} | 9,438 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
} | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
640,
821
]
} | 9,439 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
5295,
5415
]
} | 9,440 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
5486,
5582
]
} | 9,441 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
5750,
6178
]
} | 9,442 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
| /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
6470,
6647
]
} | 9,443 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
7938,
8162
]
} | 9,444 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
8500,
8639
]
} | 9,445 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
9124,
9427
]
} | 9,446 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | decreaseApproval | function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
| /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
9917,
10391
]
} | 9,447 |
|
SKYFToken | SKYFToken.sol | 0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68 | Solidity | SKYFToken | contract SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
/**
* @dev ERC20 descriptor variables
*/
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
/**
* @dev Contract constructor
*/
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed 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;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public erc20Allowed {
_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);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
} | /**
* @title SKYFChain Tokens
* @dev SKYFChain Token, ERC20 implementation, contract based on Zeppelin contracts:
* Ownable, BasicToken, StandardToken, ERC20Basic, Burnable
*/ | NatSpecMultiLine | burn | function burn(uint256 _value) public erc20Allowed {
_burn(msg.sender, _value);
}
| /**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://aba4fccf134a19c1b986b116186415ec4946963de5ba9fdb6225959805341c85 | {
"func_code_index": [
10515,
10614
]
} | 9,448 |
|
babyShib | babyShib.sol | 0x9701fe45f219f38c55f39872c84002202bcc512a | Solidity | Context | contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
} | _msgSender | function _msgSender() internal view returns(address payable) {
return msg.sender;
}
| // solhint-disable-previous-line no-empty-blocks | LineComment | v0.5.17+commit.d19bba13 | MIT | bzzr://e30438a0f9c5bdbcd3f2dd4b74fc6bc0aa270a72ef84595f8847ce05891bb513 | {
"func_code_index": [
105,
207
]
} | 9,449 |
||
PilotPunks | @openzeppelin/contracts/access/Ownable.sol | 0xf4dba4e7b646500b69101619a2af5ed3b51a3d1d | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | owner | function owner() public view virtual returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://179c887c92d5976508b56a7c38d6edbc8a84e49b3586a76ba7168d93111012a8 | {
"func_code_index": [
399,
491
]
} | 9,450 |
PilotPunks | @openzeppelin/contracts/access/Ownable.sol | 0xf4dba4e7b646500b69101619a2af5ed3b51a3d1d | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://179c887c92d5976508b56a7c38d6edbc8a84e49b3586a76ba7168d93111012a8 | {
"func_code_index": [
1050,
1149
]
} | 9,451 |
PilotPunks | @openzeppelin/contracts/access/Ownable.sol | 0xf4dba4e7b646500b69101619a2af5ed3b51a3d1d | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://179c887c92d5976508b56a7c38d6edbc8a84e49b3586a76ba7168d93111012a8 | {
"func_code_index": [
1299,
1496
]
} | 9,452 |
PilotPunks | @openzeppelin/contracts/access/Ownable.sol | 0xf4dba4e7b646500b69101619a2af5ed3b51a3d1d | Solidity | PilotPunks | contract PilotPunks is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.000000000000000001 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmount = 200;
uint256 public nftPerAddressLimit = 100;
bool public paused = true;
bool public revealed = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
setBaseURI(_initBaseURI);
setNotRevealedURI(_initNotRevealedUri);
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
// public
function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
if (onlyWhitelisted == true){
require(isWhitelisted(msg.sender), "user is not whitelisted");
uint256 ownerTokenCount = balanceOf(msg.sender);
require(ownerTokenCount < nftPerAddressLimit, "max NFT per address exceeded");
}
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(address _user) public view returns (bool){
for(uint256 i = 0; i < whitelistedAddresses.length; i++){
if(whitelistedAddresses[i] == _user){
return true;
}
}
return false;
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
uint256 ownerTokenCount = balanceOf(_owner);
uint256[] memory tokenIds = new uint256[](ownerTokenCount);
for (uint256 i; i < ownerTokenCount; i++) {
tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokenIds;
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
if(revealed == false) {
return notRevealedUri;
}
string memory currentBaseURI = _baseURI();
return bytes(currentBaseURI).length > 0
? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
: "";
}
//only owner
function reveal() public onlyOwner {
revealed = true;
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
nftPerAddressLimit = _limit;
}
function setCost(uint256 _newCost) public onlyOwner {
cost = _newCost;
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
maxMintAmount = _newmaxMintAmount;
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
notRevealedUri = _notRevealedURI;
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
baseExtension = _newBaseExtension;
}
function pause(bool _state) public onlyOwner {
paused = _state;
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
onlyWhitelisted = _state;
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
delete whitelistedAddresses;
whitelistedAddresses = _users;
}
function withdraw() public payable onlyOwner {
// This will pay HashLips 5% of the initial sale.
// You can remove this if you want, or keep it in to support HashLips and his channel.
// =============================================================================
(bool hs, ) = payable(0x943590A42C27D08e3744202c4Ae5eD55c2dE240D).call{value: address(this).balance * 5 / 100}("");
require(hs);
// =============================================================================
// This will payout the owner 95% of the contract balance.
// Do not remove this otherwise you will not be able to withdraw the funds.
// =============================================================================
(bool os, ) = payable(owner()).call{value: address(this).balance}("");
require(os);
// =============================================================================
}
} | _baseURI | function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
| // internal | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://179c887c92d5976508b56a7c38d6edbc8a84e49b3586a76ba7168d93111012a8 | {
"func_code_index": [
769,
874
]
} | 9,453 |
||
PilotPunks | @openzeppelin/contracts/access/Ownable.sol | 0xf4dba4e7b646500b69101619a2af5ed3b51a3d1d | Solidity | PilotPunks | contract PilotPunks is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.000000000000000001 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmount = 200;
uint256 public nftPerAddressLimit = 100;
bool public paused = true;
bool public revealed = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
setBaseURI(_initBaseURI);
setNotRevealedURI(_initNotRevealedUri);
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
// public
function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
if (onlyWhitelisted == true){
require(isWhitelisted(msg.sender), "user is not whitelisted");
uint256 ownerTokenCount = balanceOf(msg.sender);
require(ownerTokenCount < nftPerAddressLimit, "max NFT per address exceeded");
}
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(address _user) public view returns (bool){
for(uint256 i = 0; i < whitelistedAddresses.length; i++){
if(whitelistedAddresses[i] == _user){
return true;
}
}
return false;
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
uint256 ownerTokenCount = balanceOf(_owner);
uint256[] memory tokenIds = new uint256[](ownerTokenCount);
for (uint256 i; i < ownerTokenCount; i++) {
tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokenIds;
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
if(revealed == false) {
return notRevealedUri;
}
string memory currentBaseURI = _baseURI();
return bytes(currentBaseURI).length > 0
? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
: "";
}
//only owner
function reveal() public onlyOwner {
revealed = true;
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
nftPerAddressLimit = _limit;
}
function setCost(uint256 _newCost) public onlyOwner {
cost = _newCost;
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
maxMintAmount = _newmaxMintAmount;
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
notRevealedUri = _notRevealedURI;
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
baseExtension = _newBaseExtension;
}
function pause(bool _state) public onlyOwner {
paused = _state;
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
onlyWhitelisted = _state;
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
delete whitelistedAddresses;
whitelistedAddresses = _users;
}
function withdraw() public payable onlyOwner {
// This will pay HashLips 5% of the initial sale.
// You can remove this if you want, or keep it in to support HashLips and his channel.
// =============================================================================
(bool hs, ) = payable(0x943590A42C27D08e3744202c4Ae5eD55c2dE240D).call{value: address(this).balance * 5 / 100}("");
require(hs);
// =============================================================================
// This will payout the owner 95% of the contract balance.
// Do not remove this otherwise you will not be able to withdraw the funds.
// =============================================================================
(bool os, ) = payable(owner()).call{value: address(this).balance}("");
require(os);
// =============================================================================
}
} | mint | function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
if (onlyWhitelisted == true){
require(isWhitelisted(msg.sender), "user is not whitelisted");
uint256 ownerTokenCount = balanceOf(msg.sender);
require(ownerTokenCount < nftPerAddressLimit, "max NFT per address exceeded");
}
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, supply + i);
}
}
| // public | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://179c887c92d5976508b56a7c38d6edbc8a84e49b3586a76ba7168d93111012a8 | {
"func_code_index": [
890,
1753
]
} | 9,454 |
||
PilotPunks | @openzeppelin/contracts/access/Ownable.sol | 0xf4dba4e7b646500b69101619a2af5ed3b51a3d1d | Solidity | PilotPunks | contract PilotPunks is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.000000000000000001 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmount = 200;
uint256 public nftPerAddressLimit = 100;
bool public paused = true;
bool public revealed = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
setBaseURI(_initBaseURI);
setNotRevealedURI(_initNotRevealedUri);
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
// public
function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
if (onlyWhitelisted == true){
require(isWhitelisted(msg.sender), "user is not whitelisted");
uint256 ownerTokenCount = balanceOf(msg.sender);
require(ownerTokenCount < nftPerAddressLimit, "max NFT per address exceeded");
}
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(address _user) public view returns (bool){
for(uint256 i = 0; i < whitelistedAddresses.length; i++){
if(whitelistedAddresses[i] == _user){
return true;
}
}
return false;
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
uint256 ownerTokenCount = balanceOf(_owner);
uint256[] memory tokenIds = new uint256[](ownerTokenCount);
for (uint256 i; i < ownerTokenCount; i++) {
tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
}
return tokenIds;
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(
_exists(tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
if(revealed == false) {
return notRevealedUri;
}
string memory currentBaseURI = _baseURI();
return bytes(currentBaseURI).length > 0
? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
: "";
}
//only owner
function reveal() public onlyOwner {
revealed = true;
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
nftPerAddressLimit = _limit;
}
function setCost(uint256 _newCost) public onlyOwner {
cost = _newCost;
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
maxMintAmount = _newmaxMintAmount;
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
notRevealedUri = _notRevealedURI;
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
baseURI = _newBaseURI;
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
baseExtension = _newBaseExtension;
}
function pause(bool _state) public onlyOwner {
paused = _state;
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
onlyWhitelisted = _state;
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
delete whitelistedAddresses;
whitelistedAddresses = _users;
}
function withdraw() public payable onlyOwner {
// This will pay HashLips 5% of the initial sale.
// You can remove this if you want, or keep it in to support HashLips and his channel.
// =============================================================================
(bool hs, ) = payable(0x943590A42C27D08e3744202c4Ae5eD55c2dE240D).call{value: address(this).balance * 5 / 100}("");
require(hs);
// =============================================================================
// This will payout the owner 95% of the contract balance.
// Do not remove this otherwise you will not be able to withdraw the funds.
// =============================================================================
(bool os, ) = payable(owner()).call{value: address(this).balance}("");
require(os);
// =============================================================================
}
} | reveal | function reveal() public onlyOwner {
revealed = true;
}
| //only owner | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://179c887c92d5976508b56a7c38d6edbc8a84e49b3586a76ba7168d93111012a8 | {
"func_code_index": [
2890,
2958
]
} | 9,455 |
||
CryptoSurprise | CryptoSurprise.sol | 0xfc88a9f06f5fe0de2dac95c5fada7a8b3b3d610d | Solidity | CryptoSurprise | contract CryptoSurprise
{
using SetLibrary for SetLibrary.Set;
////////////////////////////////////
////// CONSTANTS
uint256 constant public BAG_TRANSFER_FEE = 0.05 ether;
uint256 constant public BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS = 4;
////////////////////////////////////
////// STATE VARIABLES
struct BagType
{
// Constants
string name;
uint256 startPrice;
uint256 priceMultiplierPerBuy; // For example, 2 000 000 means 100% increase. (100% = doubling every buy)
uint256 startCommission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 commissionIncrementPerBuy;
uint256 maximumCommission;
uint256 supplyHardCap;
// Variables
uint256 currentSupply;
}
struct Bag
{
// Constants
uint256 bagTypeIndex;
// Variables
uint256 amountOfBuys;
address owner;
uint256 commission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 price;
uint256 availableTimestamp;
}
// Variable that remembers the current owner
address public owner;
BagType[] public bagTypes;
Bag[] public bags;
mapping(address => uint256) public addressToTotalEtherSpent;
mapping(address => uint256) public addressToTotalPurchasesMade;
mapping(address => SetLibrary.Set) private ownerToBagIndices;
address[] public allParticipants;
////////////////////////////////////
////// PLAYER FUNCTIONS
function buyBag(uint256 _bagIndex) external payable
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Reference the bag data and bag type data
Bag storage bag = bags[_bagIndex];
BagType storage bagType = bagTypes[bag.bagTypeIndex];
// Make sure the bag is already available
require(now >= bag.availableTimestamp);
// Make sure the caller payed at least the current price
require(msg.value >= bag.price);
uint256 refund = msg.value - bag.price;
// Remember who the previous owner was
address previousOwner = bag.owner;
// Set the buyer as the new owner
bag.owner = msg.sender;
// Calculate the previous and next price
uint256 previousPrice = bag.price * 1000000 / bagType.priceMultiplierPerBuy;
uint256 nextPrice = bag.price * bagType.priceMultiplierPerBuy / 1000000;
// Calculate how much the previous owner should get:
uint256 previousOwnerReward;
// If this is the first buy: the full current price
if (bag.amountOfBuys == 0)
{
previousOwnerReward = bag.price;
}
// otherwise: previous price + the commission
else
{
previousOwnerReward = bag.price * bag.commission / 1000000;
//previousOwnerReward = previousPrice + previousPrice * bag.commission / 1000000;
}
// Set the new price of the bag
bag.price = nextPrice;
// Increment the amountOfBuys counter
bag.amountOfBuys++;
// If this is NOT the first buy of this bag:
if (bag.amountOfBuys > 1)
{
// Increase the commission up to the maximum
if (bag.commission < bagType.maximumCommission)
{
uint256 newCommission = bag.commission + bagType.commissionIncrementPerBuy;
if (newCommission >= bagType.maximumCommission)
{
bag.commission = bagType.maximumCommission;
}
else
{
bag.commission = newCommission;
}
}
}
// Record statistics
if (addressToTotalPurchasesMade[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
addressToTotalEtherSpent[msg.sender] += msg.value;
addressToTotalPurchasesMade[msg.sender]++;
// Transfer the reward to the previous owner. If the previous owner is
// the CryptoSurprise smart contract itself, we don't need to perform any
// transfer because the contract already has it.
if (previousOwner != address(this))
{
previousOwner.transfer(previousOwnerReward);
}
if (refund > 0)
{
msg.sender.transfer(refund);
}
}
function transferBag(address _newOwner, uint256 _bagIndex) public payable
{
// Require payment
require(msg.value == BAG_TRANSFER_FEE);
// Perform the transfer
_transferBag(msg.sender, _newOwner, _bagIndex);
}
////////////////////////////////////
////// OWNER FUNCTIONS
// Constructor function
function CryptoSurprise() public
{
owner = msg.sender;
bagTypes.push(BagType({
name: "Blue",
startPrice: 0.04 ether,
priceMultiplierPerBuy: 1300000, // 130%
startCommission: 850000, // 85%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 900000, // 90%
supplyHardCap: 600,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Red",
startPrice: 0.03 ether,
priceMultiplierPerBuy: 1330000, // 133%
startCommission: 870000, // 87%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 920000, // 92%
supplyHardCap: 300,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Green",
startPrice: 0.02 ether,
priceMultiplierPerBuy: 1360000, // 136%
startCommission: 890000, // 89%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 940000, // 94%
supplyHardCap: 150,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Black",
startPrice: 0.1 ether,
priceMultiplierPerBuy: 1450000, // 145%
startCommission: 920000, // 92%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 960000, // 96%
supplyHardCap: 50,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Pink",
startPrice: 1 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 940000, // 94%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 980000, // 98%
supplyHardCap: 10,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "White",
startPrice: 10 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 970000, // 97%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 990000, // 99%
supplyHardCap: 1,
currentSupply: 0
}));
}
// Function that allows the current owner to transfer ownership
function transferOwnership(address _newOwner) external
{
require(msg.sender == owner);
owner = _newOwner;
}
// Only the owner can deposit ETH by sending it directly to the contract
function () payable external
{
require(msg.sender == owner);
}
// Function that allows the current owner to withdraw any amount
// of ETH from the contract
function withdrawEther(uint256 amount) external
{
require(msg.sender == owner);
owner.transfer(amount);
}
function addBag(uint256 _bagTypeIndex) external
{
addBagAndGift(_bagTypeIndex, address(this));
}
function addBagDelayed(uint256 _bagTypeIndex, uint256 _delaySeconds) external
{
addBagAndGiftAtTime(_bagTypeIndex, address(this), now + _delaySeconds);
}
function addBagAndGift(uint256 _bagTypeIndex, address _firstOwner) public
{
addBagAndGiftAtTime(_bagTypeIndex, _firstOwner, now);
}
function addBagAndGiftAtTime(uint256 _bagTypeIndex, address _firstOwner, uint256 _timestamp) public
{
require(msg.sender == owner);
require(_bagTypeIndex < bagTypes.length);
BagType storage bagType = bagTypes[_bagTypeIndex];
require(bagType.currentSupply < bagType.supplyHardCap);
bags.push(Bag({
bagTypeIndex: _bagTypeIndex,
amountOfBuys: 0,
owner: _firstOwner,
commission: bagType.startCommission,
price: bagType.startPrice,
availableTimestamp: _timestamp
}));
bagType.currentSupply++;
}
////////////////////////////////////
////// INTERNAL FUNCTIONS
function _transferBag(address _from, address _to, uint256 _bagIndex) internal
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Bag may not be transferred before it has been bought x times
require(bags[_bagIndex].amountOfBuys >= BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS);
// Make sure that the sender is the current owner of the bag
require(bags[_bagIndex].owner == _from);
// Set the new owner
bags[_bagIndex].owner = _to;
ownerToBagIndices[_from].remove(_bagIndex);
ownerToBagIndices[_to].add(_bagIndex);
// Trigger blockchain event
Transfer(_from, _to, _bagIndex);
}
////////////////////////////////////
////// VIEW FUNCTIONS FOR USER INTERFACE
function amountOfBags() external view returns (uint256)
{
return bags.length;
}
function amountOfBagTypes() external view returns (uint256)
{
return bagTypes.length;
}
function amountOfParticipants() external view returns (uint256)
{
return allParticipants.length;
}
////////////////////////////////////
////// ERC721 NON FUNGIBLE TOKEN INTERFACE
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function name() external pure returns (string)
{
return "Bags";
}
function symbol() external pure returns (string)
{
return "BAG";
}
function totalSupply() external view returns (uint256)
{
return bags.length;
}
function balanceOf(address _owner) external view returns (uint256)
{
return ownerToBagIndices[_owner].size();
}
function ownerOf(uint256 _bagIndex) external view returns (address)
{
require(_bagIndex < bags.length);
return bags[_bagIndex].owner;
}
mapping(address => mapping(address => mapping(uint256 => bool))) private ownerToAddressToBagIndexAllowed;
function approve(address _to, uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
require(msg.sender == bags[_bagIndex].owner);
ownerToAddressToBagIndexAllowed[msg.sender][_to][_bagIndex] = true;
}
function takeOwnership(uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
address previousOwner = bags[_bagIndex].owner;
require(ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] == true);
ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] = false;
_transferBag(previousOwner, msg.sender, _bagIndex);
}
function transfer(address _to, uint256 _bagIndex) external
{
transferBag(_to, _bagIndex);
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256)
{
require(_index < ownerToBagIndices[_owner].size());
return ownerToBagIndices[_owner].values[_index];
}
} | ////////////////////////////////////
////// CRYPTO SURPRISE
////// https://cryptosurprise.me
//////////////////////////////////// | NatSpecSingleLine | buyBag | function buyBag(uint256 _bagIndex) external payable
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Reference the bag data and bag type data
Bag storage bag = bags[_bagIndex];
BagType storage bagType = bagTypes[bag.bagTypeIndex];
// Make sure the bag is already available
require(now >= bag.availableTimestamp);
// Make sure the caller payed at least the current price
require(msg.value >= bag.price);
uint256 refund = msg.value - bag.price;
// Remember who the previous owner was
address previousOwner = bag.owner;
// Set the buyer as the new owner
bag.owner = msg.sender;
// Calculate the previous and next price
uint256 previousPrice = bag.price * 1000000 / bagType.priceMultiplierPerBuy;
uint256 nextPrice = bag.price * bagType.priceMultiplierPerBuy / 1000000;
// Calculate how much the previous owner should get:
uint256 previousOwnerReward;
// If this is the first buy: the full current price
if (bag.amountOfBuys == 0)
{
previousOwnerReward = bag.price;
}
// otherwise: previous price + the commission
else
{
previousOwnerReward = bag.price * bag.commission / 1000000;
//previousOwnerReward = previousPrice + previousPrice * bag.commission / 1000000;
}
// Set the new price of the bag
bag.price = nextPrice;
// Increment the amountOfBuys counter
bag.amountOfBuys++;
// If this is NOT the first buy of this bag:
if (bag.amountOfBuys > 1)
{
// Increase the commission up to the maximum
if (bag.commission < bagType.maximumCommission)
{
uint256 newCommission = bag.commission + bagType.commissionIncrementPerBuy;
if (newCommission >= bagType.maximumCommission)
{
bag.commission = bagType.maximumCommission;
}
else
{
bag.commission = newCommission;
}
}
}
// Record statistics
if (addressToTotalPurchasesMade[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
addressToTotalEtherSpent[msg.sender] += msg.value;
addressToTotalPurchasesMade[msg.sender]++;
// Transfer the reward to the previous owner. If the previous owner is
// the CryptoSurprise smart contract itself, we don't need to perform any
// transfer because the contract already has it.
if (previousOwner != address(this))
{
previousOwner.transfer(previousOwnerReward);
}
if (refund > 0)
{
msg.sender.transfer(refund);
}
}
| ////////////////////////////////////
////// PLAYER FUNCTIONS | NatSpecSingleLine | v0.4.20+commit.3155dd80 | bzzr://344941c93384be2385ef37755c9aaa5684448e3fd92bb21795385eee1d2b7c23 | {
"func_code_index": [
1675,
4814
]
} | 9,456 |
|
CryptoSurprise | CryptoSurprise.sol | 0xfc88a9f06f5fe0de2dac95c5fada7a8b3b3d610d | Solidity | CryptoSurprise | contract CryptoSurprise
{
using SetLibrary for SetLibrary.Set;
////////////////////////////////////
////// CONSTANTS
uint256 constant public BAG_TRANSFER_FEE = 0.05 ether;
uint256 constant public BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS = 4;
////////////////////////////////////
////// STATE VARIABLES
struct BagType
{
// Constants
string name;
uint256 startPrice;
uint256 priceMultiplierPerBuy; // For example, 2 000 000 means 100% increase. (100% = doubling every buy)
uint256 startCommission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 commissionIncrementPerBuy;
uint256 maximumCommission;
uint256 supplyHardCap;
// Variables
uint256 currentSupply;
}
struct Bag
{
// Constants
uint256 bagTypeIndex;
// Variables
uint256 amountOfBuys;
address owner;
uint256 commission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 price;
uint256 availableTimestamp;
}
// Variable that remembers the current owner
address public owner;
BagType[] public bagTypes;
Bag[] public bags;
mapping(address => uint256) public addressToTotalEtherSpent;
mapping(address => uint256) public addressToTotalPurchasesMade;
mapping(address => SetLibrary.Set) private ownerToBagIndices;
address[] public allParticipants;
////////////////////////////////////
////// PLAYER FUNCTIONS
function buyBag(uint256 _bagIndex) external payable
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Reference the bag data and bag type data
Bag storage bag = bags[_bagIndex];
BagType storage bagType = bagTypes[bag.bagTypeIndex];
// Make sure the bag is already available
require(now >= bag.availableTimestamp);
// Make sure the caller payed at least the current price
require(msg.value >= bag.price);
uint256 refund = msg.value - bag.price;
// Remember who the previous owner was
address previousOwner = bag.owner;
// Set the buyer as the new owner
bag.owner = msg.sender;
// Calculate the previous and next price
uint256 previousPrice = bag.price * 1000000 / bagType.priceMultiplierPerBuy;
uint256 nextPrice = bag.price * bagType.priceMultiplierPerBuy / 1000000;
// Calculate how much the previous owner should get:
uint256 previousOwnerReward;
// If this is the first buy: the full current price
if (bag.amountOfBuys == 0)
{
previousOwnerReward = bag.price;
}
// otherwise: previous price + the commission
else
{
previousOwnerReward = bag.price * bag.commission / 1000000;
//previousOwnerReward = previousPrice + previousPrice * bag.commission / 1000000;
}
// Set the new price of the bag
bag.price = nextPrice;
// Increment the amountOfBuys counter
bag.amountOfBuys++;
// If this is NOT the first buy of this bag:
if (bag.amountOfBuys > 1)
{
// Increase the commission up to the maximum
if (bag.commission < bagType.maximumCommission)
{
uint256 newCommission = bag.commission + bagType.commissionIncrementPerBuy;
if (newCommission >= bagType.maximumCommission)
{
bag.commission = bagType.maximumCommission;
}
else
{
bag.commission = newCommission;
}
}
}
// Record statistics
if (addressToTotalPurchasesMade[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
addressToTotalEtherSpent[msg.sender] += msg.value;
addressToTotalPurchasesMade[msg.sender]++;
// Transfer the reward to the previous owner. If the previous owner is
// the CryptoSurprise smart contract itself, we don't need to perform any
// transfer because the contract already has it.
if (previousOwner != address(this))
{
previousOwner.transfer(previousOwnerReward);
}
if (refund > 0)
{
msg.sender.transfer(refund);
}
}
function transferBag(address _newOwner, uint256 _bagIndex) public payable
{
// Require payment
require(msg.value == BAG_TRANSFER_FEE);
// Perform the transfer
_transferBag(msg.sender, _newOwner, _bagIndex);
}
////////////////////////////////////
////// OWNER FUNCTIONS
// Constructor function
function CryptoSurprise() public
{
owner = msg.sender;
bagTypes.push(BagType({
name: "Blue",
startPrice: 0.04 ether,
priceMultiplierPerBuy: 1300000, // 130%
startCommission: 850000, // 85%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 900000, // 90%
supplyHardCap: 600,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Red",
startPrice: 0.03 ether,
priceMultiplierPerBuy: 1330000, // 133%
startCommission: 870000, // 87%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 920000, // 92%
supplyHardCap: 300,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Green",
startPrice: 0.02 ether,
priceMultiplierPerBuy: 1360000, // 136%
startCommission: 890000, // 89%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 940000, // 94%
supplyHardCap: 150,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Black",
startPrice: 0.1 ether,
priceMultiplierPerBuy: 1450000, // 145%
startCommission: 920000, // 92%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 960000, // 96%
supplyHardCap: 50,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Pink",
startPrice: 1 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 940000, // 94%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 980000, // 98%
supplyHardCap: 10,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "White",
startPrice: 10 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 970000, // 97%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 990000, // 99%
supplyHardCap: 1,
currentSupply: 0
}));
}
// Function that allows the current owner to transfer ownership
function transferOwnership(address _newOwner) external
{
require(msg.sender == owner);
owner = _newOwner;
}
// Only the owner can deposit ETH by sending it directly to the contract
function () payable external
{
require(msg.sender == owner);
}
// Function that allows the current owner to withdraw any amount
// of ETH from the contract
function withdrawEther(uint256 amount) external
{
require(msg.sender == owner);
owner.transfer(amount);
}
function addBag(uint256 _bagTypeIndex) external
{
addBagAndGift(_bagTypeIndex, address(this));
}
function addBagDelayed(uint256 _bagTypeIndex, uint256 _delaySeconds) external
{
addBagAndGiftAtTime(_bagTypeIndex, address(this), now + _delaySeconds);
}
function addBagAndGift(uint256 _bagTypeIndex, address _firstOwner) public
{
addBagAndGiftAtTime(_bagTypeIndex, _firstOwner, now);
}
function addBagAndGiftAtTime(uint256 _bagTypeIndex, address _firstOwner, uint256 _timestamp) public
{
require(msg.sender == owner);
require(_bagTypeIndex < bagTypes.length);
BagType storage bagType = bagTypes[_bagTypeIndex];
require(bagType.currentSupply < bagType.supplyHardCap);
bags.push(Bag({
bagTypeIndex: _bagTypeIndex,
amountOfBuys: 0,
owner: _firstOwner,
commission: bagType.startCommission,
price: bagType.startPrice,
availableTimestamp: _timestamp
}));
bagType.currentSupply++;
}
////////////////////////////////////
////// INTERNAL FUNCTIONS
function _transferBag(address _from, address _to, uint256 _bagIndex) internal
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Bag may not be transferred before it has been bought x times
require(bags[_bagIndex].amountOfBuys >= BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS);
// Make sure that the sender is the current owner of the bag
require(bags[_bagIndex].owner == _from);
// Set the new owner
bags[_bagIndex].owner = _to;
ownerToBagIndices[_from].remove(_bagIndex);
ownerToBagIndices[_to].add(_bagIndex);
// Trigger blockchain event
Transfer(_from, _to, _bagIndex);
}
////////////////////////////////////
////// VIEW FUNCTIONS FOR USER INTERFACE
function amountOfBags() external view returns (uint256)
{
return bags.length;
}
function amountOfBagTypes() external view returns (uint256)
{
return bagTypes.length;
}
function amountOfParticipants() external view returns (uint256)
{
return allParticipants.length;
}
////////////////////////////////////
////// ERC721 NON FUNGIBLE TOKEN INTERFACE
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function name() external pure returns (string)
{
return "Bags";
}
function symbol() external pure returns (string)
{
return "BAG";
}
function totalSupply() external view returns (uint256)
{
return bags.length;
}
function balanceOf(address _owner) external view returns (uint256)
{
return ownerToBagIndices[_owner].size();
}
function ownerOf(uint256 _bagIndex) external view returns (address)
{
require(_bagIndex < bags.length);
return bags[_bagIndex].owner;
}
mapping(address => mapping(address => mapping(uint256 => bool))) private ownerToAddressToBagIndexAllowed;
function approve(address _to, uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
require(msg.sender == bags[_bagIndex].owner);
ownerToAddressToBagIndexAllowed[msg.sender][_to][_bagIndex] = true;
}
function takeOwnership(uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
address previousOwner = bags[_bagIndex].owner;
require(ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] == true);
ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] = false;
_transferBag(previousOwner, msg.sender, _bagIndex);
}
function transfer(address _to, uint256 _bagIndex) external
{
transferBag(_to, _bagIndex);
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256)
{
require(_index < ownerToBagIndices[_owner].size());
return ownerToBagIndices[_owner].values[_index];
}
} | ////////////////////////////////////
////// CRYPTO SURPRISE
////// https://cryptosurprise.me
//////////////////////////////////// | NatSpecSingleLine | CryptoSurprise | function CryptoSurprise() public
{
owner = msg.sender;
bagTypes.push(BagType({
name: "Blue",
startPrice: 0.04 ether,
priceMultiplierPerBuy: 1300000, // 130%
startCommission: 850000, // 85%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 900000, // 90%
supplyHardCap: 600,
currentSupply: 0
}));
gTypes.push(BagType({
name: "Red",
startPrice: 0.03 ether,
priceMultiplierPerBuy: 1330000, // 133%
startCommission: 870000, // 87%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 920000, // 92%
supplyHardCap: 300,
currentSupply: 0
}));
gTypes.push(BagType({
name: "Green",
startPrice: 0.02 ether,
priceMultiplierPerBuy: 1360000, // 136%
startCommission: 890000, // 89%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 940000, // 94%
supplyHardCap: 150,
currentSupply: 0
}));
gTypes.push(BagType({
name: "Black",
startPrice: 0.1 ether,
priceMultiplierPerBuy: 1450000, // 145%
startCommission: 920000, // 92%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 960000, // 96%
supplyHardCap: 50,
currentSupply: 0
}));
gTypes.push(BagType({
name: "Pink",
startPrice: 1 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 940000, // 94%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 980000, // 98%
supplyHardCap: 10,
currentSupply: 0
}));
gTypes.push(BagType({
name: "White",
startPrice: 10 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 970000, // 97%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 990000, // 99%
supplyHardCap: 1,
currentSupply: 0
}));
}
| // Constructor function | LineComment | v0.4.20+commit.3155dd80 | bzzr://344941c93384be2385ef37755c9aaa5684448e3fd92bb21795385eee1d2b7c23 | {
"func_code_index": [
5208,
7873
]
} | 9,457 |
|
CryptoSurprise | CryptoSurprise.sol | 0xfc88a9f06f5fe0de2dac95c5fada7a8b3b3d610d | Solidity | CryptoSurprise | contract CryptoSurprise
{
using SetLibrary for SetLibrary.Set;
////////////////////////////////////
////// CONSTANTS
uint256 constant public BAG_TRANSFER_FEE = 0.05 ether;
uint256 constant public BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS = 4;
////////////////////////////////////
////// STATE VARIABLES
struct BagType
{
// Constants
string name;
uint256 startPrice;
uint256 priceMultiplierPerBuy; // For example, 2 000 000 means 100% increase. (100% = doubling every buy)
uint256 startCommission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 commissionIncrementPerBuy;
uint256 maximumCommission;
uint256 supplyHardCap;
// Variables
uint256 currentSupply;
}
struct Bag
{
// Constants
uint256 bagTypeIndex;
// Variables
uint256 amountOfBuys;
address owner;
uint256 commission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 price;
uint256 availableTimestamp;
}
// Variable that remembers the current owner
address public owner;
BagType[] public bagTypes;
Bag[] public bags;
mapping(address => uint256) public addressToTotalEtherSpent;
mapping(address => uint256) public addressToTotalPurchasesMade;
mapping(address => SetLibrary.Set) private ownerToBagIndices;
address[] public allParticipants;
////////////////////////////////////
////// PLAYER FUNCTIONS
function buyBag(uint256 _bagIndex) external payable
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Reference the bag data and bag type data
Bag storage bag = bags[_bagIndex];
BagType storage bagType = bagTypes[bag.bagTypeIndex];
// Make sure the bag is already available
require(now >= bag.availableTimestamp);
// Make sure the caller payed at least the current price
require(msg.value >= bag.price);
uint256 refund = msg.value - bag.price;
// Remember who the previous owner was
address previousOwner = bag.owner;
// Set the buyer as the new owner
bag.owner = msg.sender;
// Calculate the previous and next price
uint256 previousPrice = bag.price * 1000000 / bagType.priceMultiplierPerBuy;
uint256 nextPrice = bag.price * bagType.priceMultiplierPerBuy / 1000000;
// Calculate how much the previous owner should get:
uint256 previousOwnerReward;
// If this is the first buy: the full current price
if (bag.amountOfBuys == 0)
{
previousOwnerReward = bag.price;
}
// otherwise: previous price + the commission
else
{
previousOwnerReward = bag.price * bag.commission / 1000000;
//previousOwnerReward = previousPrice + previousPrice * bag.commission / 1000000;
}
// Set the new price of the bag
bag.price = nextPrice;
// Increment the amountOfBuys counter
bag.amountOfBuys++;
// If this is NOT the first buy of this bag:
if (bag.amountOfBuys > 1)
{
// Increase the commission up to the maximum
if (bag.commission < bagType.maximumCommission)
{
uint256 newCommission = bag.commission + bagType.commissionIncrementPerBuy;
if (newCommission >= bagType.maximumCommission)
{
bag.commission = bagType.maximumCommission;
}
else
{
bag.commission = newCommission;
}
}
}
// Record statistics
if (addressToTotalPurchasesMade[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
addressToTotalEtherSpent[msg.sender] += msg.value;
addressToTotalPurchasesMade[msg.sender]++;
// Transfer the reward to the previous owner. If the previous owner is
// the CryptoSurprise smart contract itself, we don't need to perform any
// transfer because the contract already has it.
if (previousOwner != address(this))
{
previousOwner.transfer(previousOwnerReward);
}
if (refund > 0)
{
msg.sender.transfer(refund);
}
}
function transferBag(address _newOwner, uint256 _bagIndex) public payable
{
// Require payment
require(msg.value == BAG_TRANSFER_FEE);
// Perform the transfer
_transferBag(msg.sender, _newOwner, _bagIndex);
}
////////////////////////////////////
////// OWNER FUNCTIONS
// Constructor function
function CryptoSurprise() public
{
owner = msg.sender;
bagTypes.push(BagType({
name: "Blue",
startPrice: 0.04 ether,
priceMultiplierPerBuy: 1300000, // 130%
startCommission: 850000, // 85%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 900000, // 90%
supplyHardCap: 600,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Red",
startPrice: 0.03 ether,
priceMultiplierPerBuy: 1330000, // 133%
startCommission: 870000, // 87%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 920000, // 92%
supplyHardCap: 300,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Green",
startPrice: 0.02 ether,
priceMultiplierPerBuy: 1360000, // 136%
startCommission: 890000, // 89%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 940000, // 94%
supplyHardCap: 150,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Black",
startPrice: 0.1 ether,
priceMultiplierPerBuy: 1450000, // 145%
startCommission: 920000, // 92%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 960000, // 96%
supplyHardCap: 50,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Pink",
startPrice: 1 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 940000, // 94%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 980000, // 98%
supplyHardCap: 10,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "White",
startPrice: 10 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 970000, // 97%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 990000, // 99%
supplyHardCap: 1,
currentSupply: 0
}));
}
// Function that allows the current owner to transfer ownership
function transferOwnership(address _newOwner) external
{
require(msg.sender == owner);
owner = _newOwner;
}
// Only the owner can deposit ETH by sending it directly to the contract
function () payable external
{
require(msg.sender == owner);
}
// Function that allows the current owner to withdraw any amount
// of ETH from the contract
function withdrawEther(uint256 amount) external
{
require(msg.sender == owner);
owner.transfer(amount);
}
function addBag(uint256 _bagTypeIndex) external
{
addBagAndGift(_bagTypeIndex, address(this));
}
function addBagDelayed(uint256 _bagTypeIndex, uint256 _delaySeconds) external
{
addBagAndGiftAtTime(_bagTypeIndex, address(this), now + _delaySeconds);
}
function addBagAndGift(uint256 _bagTypeIndex, address _firstOwner) public
{
addBagAndGiftAtTime(_bagTypeIndex, _firstOwner, now);
}
function addBagAndGiftAtTime(uint256 _bagTypeIndex, address _firstOwner, uint256 _timestamp) public
{
require(msg.sender == owner);
require(_bagTypeIndex < bagTypes.length);
BagType storage bagType = bagTypes[_bagTypeIndex];
require(bagType.currentSupply < bagType.supplyHardCap);
bags.push(Bag({
bagTypeIndex: _bagTypeIndex,
amountOfBuys: 0,
owner: _firstOwner,
commission: bagType.startCommission,
price: bagType.startPrice,
availableTimestamp: _timestamp
}));
bagType.currentSupply++;
}
////////////////////////////////////
////// INTERNAL FUNCTIONS
function _transferBag(address _from, address _to, uint256 _bagIndex) internal
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Bag may not be transferred before it has been bought x times
require(bags[_bagIndex].amountOfBuys >= BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS);
// Make sure that the sender is the current owner of the bag
require(bags[_bagIndex].owner == _from);
// Set the new owner
bags[_bagIndex].owner = _to;
ownerToBagIndices[_from].remove(_bagIndex);
ownerToBagIndices[_to].add(_bagIndex);
// Trigger blockchain event
Transfer(_from, _to, _bagIndex);
}
////////////////////////////////////
////// VIEW FUNCTIONS FOR USER INTERFACE
function amountOfBags() external view returns (uint256)
{
return bags.length;
}
function amountOfBagTypes() external view returns (uint256)
{
return bagTypes.length;
}
function amountOfParticipants() external view returns (uint256)
{
return allParticipants.length;
}
////////////////////////////////////
////// ERC721 NON FUNGIBLE TOKEN INTERFACE
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function name() external pure returns (string)
{
return "Bags";
}
function symbol() external pure returns (string)
{
return "BAG";
}
function totalSupply() external view returns (uint256)
{
return bags.length;
}
function balanceOf(address _owner) external view returns (uint256)
{
return ownerToBagIndices[_owner].size();
}
function ownerOf(uint256 _bagIndex) external view returns (address)
{
require(_bagIndex < bags.length);
return bags[_bagIndex].owner;
}
mapping(address => mapping(address => mapping(uint256 => bool))) private ownerToAddressToBagIndexAllowed;
function approve(address _to, uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
require(msg.sender == bags[_bagIndex].owner);
ownerToAddressToBagIndexAllowed[msg.sender][_to][_bagIndex] = true;
}
function takeOwnership(uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
address previousOwner = bags[_bagIndex].owner;
require(ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] == true);
ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] = false;
_transferBag(previousOwner, msg.sender, _bagIndex);
}
function transfer(address _to, uint256 _bagIndex) external
{
transferBag(_to, _bagIndex);
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256)
{
require(_index < ownerToBagIndices[_owner].size());
return ownerToBagIndices[_owner].values[_index];
}
} | ////////////////////////////////////
////// CRYPTO SURPRISE
////// https://cryptosurprise.me
//////////////////////////////////// | NatSpecSingleLine | transferOwnership | function transferOwnership(address _newOwner) external
{
require(msg.sender == owner);
owner = _newOwner;
}
| // Function that allows the current owner to transfer ownership | LineComment | v0.4.20+commit.3155dd80 | bzzr://344941c93384be2385ef37755c9aaa5684448e3fd92bb21795385eee1d2b7c23 | {
"func_code_index": [
7949,
8089
]
} | 9,458 |
|
CryptoSurprise | CryptoSurprise.sol | 0xfc88a9f06f5fe0de2dac95c5fada7a8b3b3d610d | Solidity | CryptoSurprise | contract CryptoSurprise
{
using SetLibrary for SetLibrary.Set;
////////////////////////////////////
////// CONSTANTS
uint256 constant public BAG_TRANSFER_FEE = 0.05 ether;
uint256 constant public BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS = 4;
////////////////////////////////////
////// STATE VARIABLES
struct BagType
{
// Constants
string name;
uint256 startPrice;
uint256 priceMultiplierPerBuy; // For example, 2 000 000 means 100% increase. (100% = doubling every buy)
uint256 startCommission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 commissionIncrementPerBuy;
uint256 maximumCommission;
uint256 supplyHardCap;
// Variables
uint256 currentSupply;
}
struct Bag
{
// Constants
uint256 bagTypeIndex;
// Variables
uint256 amountOfBuys;
address owner;
uint256 commission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 price;
uint256 availableTimestamp;
}
// Variable that remembers the current owner
address public owner;
BagType[] public bagTypes;
Bag[] public bags;
mapping(address => uint256) public addressToTotalEtherSpent;
mapping(address => uint256) public addressToTotalPurchasesMade;
mapping(address => SetLibrary.Set) private ownerToBagIndices;
address[] public allParticipants;
////////////////////////////////////
////// PLAYER FUNCTIONS
function buyBag(uint256 _bagIndex) external payable
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Reference the bag data and bag type data
Bag storage bag = bags[_bagIndex];
BagType storage bagType = bagTypes[bag.bagTypeIndex];
// Make sure the bag is already available
require(now >= bag.availableTimestamp);
// Make sure the caller payed at least the current price
require(msg.value >= bag.price);
uint256 refund = msg.value - bag.price;
// Remember who the previous owner was
address previousOwner = bag.owner;
// Set the buyer as the new owner
bag.owner = msg.sender;
// Calculate the previous and next price
uint256 previousPrice = bag.price * 1000000 / bagType.priceMultiplierPerBuy;
uint256 nextPrice = bag.price * bagType.priceMultiplierPerBuy / 1000000;
// Calculate how much the previous owner should get:
uint256 previousOwnerReward;
// If this is the first buy: the full current price
if (bag.amountOfBuys == 0)
{
previousOwnerReward = bag.price;
}
// otherwise: previous price + the commission
else
{
previousOwnerReward = bag.price * bag.commission / 1000000;
//previousOwnerReward = previousPrice + previousPrice * bag.commission / 1000000;
}
// Set the new price of the bag
bag.price = nextPrice;
// Increment the amountOfBuys counter
bag.amountOfBuys++;
// If this is NOT the first buy of this bag:
if (bag.amountOfBuys > 1)
{
// Increase the commission up to the maximum
if (bag.commission < bagType.maximumCommission)
{
uint256 newCommission = bag.commission + bagType.commissionIncrementPerBuy;
if (newCommission >= bagType.maximumCommission)
{
bag.commission = bagType.maximumCommission;
}
else
{
bag.commission = newCommission;
}
}
}
// Record statistics
if (addressToTotalPurchasesMade[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
addressToTotalEtherSpent[msg.sender] += msg.value;
addressToTotalPurchasesMade[msg.sender]++;
// Transfer the reward to the previous owner. If the previous owner is
// the CryptoSurprise smart contract itself, we don't need to perform any
// transfer because the contract already has it.
if (previousOwner != address(this))
{
previousOwner.transfer(previousOwnerReward);
}
if (refund > 0)
{
msg.sender.transfer(refund);
}
}
function transferBag(address _newOwner, uint256 _bagIndex) public payable
{
// Require payment
require(msg.value == BAG_TRANSFER_FEE);
// Perform the transfer
_transferBag(msg.sender, _newOwner, _bagIndex);
}
////////////////////////////////////
////// OWNER FUNCTIONS
// Constructor function
function CryptoSurprise() public
{
owner = msg.sender;
bagTypes.push(BagType({
name: "Blue",
startPrice: 0.04 ether,
priceMultiplierPerBuy: 1300000, // 130%
startCommission: 850000, // 85%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 900000, // 90%
supplyHardCap: 600,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Red",
startPrice: 0.03 ether,
priceMultiplierPerBuy: 1330000, // 133%
startCommission: 870000, // 87%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 920000, // 92%
supplyHardCap: 300,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Green",
startPrice: 0.02 ether,
priceMultiplierPerBuy: 1360000, // 136%
startCommission: 890000, // 89%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 940000, // 94%
supplyHardCap: 150,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Black",
startPrice: 0.1 ether,
priceMultiplierPerBuy: 1450000, // 145%
startCommission: 920000, // 92%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 960000, // 96%
supplyHardCap: 50,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Pink",
startPrice: 1 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 940000, // 94%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 980000, // 98%
supplyHardCap: 10,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "White",
startPrice: 10 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 970000, // 97%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 990000, // 99%
supplyHardCap: 1,
currentSupply: 0
}));
}
// Function that allows the current owner to transfer ownership
function transferOwnership(address _newOwner) external
{
require(msg.sender == owner);
owner = _newOwner;
}
// Only the owner can deposit ETH by sending it directly to the contract
function () payable external
{
require(msg.sender == owner);
}
// Function that allows the current owner to withdraw any amount
// of ETH from the contract
function withdrawEther(uint256 amount) external
{
require(msg.sender == owner);
owner.transfer(amount);
}
function addBag(uint256 _bagTypeIndex) external
{
addBagAndGift(_bagTypeIndex, address(this));
}
function addBagDelayed(uint256 _bagTypeIndex, uint256 _delaySeconds) external
{
addBagAndGiftAtTime(_bagTypeIndex, address(this), now + _delaySeconds);
}
function addBagAndGift(uint256 _bagTypeIndex, address _firstOwner) public
{
addBagAndGiftAtTime(_bagTypeIndex, _firstOwner, now);
}
function addBagAndGiftAtTime(uint256 _bagTypeIndex, address _firstOwner, uint256 _timestamp) public
{
require(msg.sender == owner);
require(_bagTypeIndex < bagTypes.length);
BagType storage bagType = bagTypes[_bagTypeIndex];
require(bagType.currentSupply < bagType.supplyHardCap);
bags.push(Bag({
bagTypeIndex: _bagTypeIndex,
amountOfBuys: 0,
owner: _firstOwner,
commission: bagType.startCommission,
price: bagType.startPrice,
availableTimestamp: _timestamp
}));
bagType.currentSupply++;
}
////////////////////////////////////
////// INTERNAL FUNCTIONS
function _transferBag(address _from, address _to, uint256 _bagIndex) internal
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Bag may not be transferred before it has been bought x times
require(bags[_bagIndex].amountOfBuys >= BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS);
// Make sure that the sender is the current owner of the bag
require(bags[_bagIndex].owner == _from);
// Set the new owner
bags[_bagIndex].owner = _to;
ownerToBagIndices[_from].remove(_bagIndex);
ownerToBagIndices[_to].add(_bagIndex);
// Trigger blockchain event
Transfer(_from, _to, _bagIndex);
}
////////////////////////////////////
////// VIEW FUNCTIONS FOR USER INTERFACE
function amountOfBags() external view returns (uint256)
{
return bags.length;
}
function amountOfBagTypes() external view returns (uint256)
{
return bagTypes.length;
}
function amountOfParticipants() external view returns (uint256)
{
return allParticipants.length;
}
////////////////////////////////////
////// ERC721 NON FUNGIBLE TOKEN INTERFACE
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function name() external pure returns (string)
{
return "Bags";
}
function symbol() external pure returns (string)
{
return "BAG";
}
function totalSupply() external view returns (uint256)
{
return bags.length;
}
function balanceOf(address _owner) external view returns (uint256)
{
return ownerToBagIndices[_owner].size();
}
function ownerOf(uint256 _bagIndex) external view returns (address)
{
require(_bagIndex < bags.length);
return bags[_bagIndex].owner;
}
mapping(address => mapping(address => mapping(uint256 => bool))) private ownerToAddressToBagIndexAllowed;
function approve(address _to, uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
require(msg.sender == bags[_bagIndex].owner);
ownerToAddressToBagIndexAllowed[msg.sender][_to][_bagIndex] = true;
}
function takeOwnership(uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
address previousOwner = bags[_bagIndex].owner;
require(ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] == true);
ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] = false;
_transferBag(previousOwner, msg.sender, _bagIndex);
}
function transfer(address _to, uint256 _bagIndex) external
{
transferBag(_to, _bagIndex);
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256)
{
require(_index < ownerToBagIndices[_owner].size());
return ownerToBagIndices[_owner].values[_index];
}
} | ////////////////////////////////////
////// CRYPTO SURPRISE
////// https://cryptosurprise.me
//////////////////////////////////// | NatSpecSingleLine | function () payable external
{
require(msg.sender == owner);
}
| // Only the owner can deposit ETH by sending it directly to the contract | LineComment | v0.4.20+commit.3155dd80 | bzzr://344941c93384be2385ef37755c9aaa5684448e3fd92bb21795385eee1d2b7c23 | {
"func_code_index": [
8174,
8260
]
} | 9,459 |
||
CryptoSurprise | CryptoSurprise.sol | 0xfc88a9f06f5fe0de2dac95c5fada7a8b3b3d610d | Solidity | CryptoSurprise | contract CryptoSurprise
{
using SetLibrary for SetLibrary.Set;
////////////////////////////////////
////// CONSTANTS
uint256 constant public BAG_TRANSFER_FEE = 0.05 ether;
uint256 constant public BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS = 4;
////////////////////////////////////
////// STATE VARIABLES
struct BagType
{
// Constants
string name;
uint256 startPrice;
uint256 priceMultiplierPerBuy; // For example, 2 000 000 means 100% increase. (100% = doubling every buy)
uint256 startCommission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 commissionIncrementPerBuy;
uint256 maximumCommission;
uint256 supplyHardCap;
// Variables
uint256 currentSupply;
}
struct Bag
{
// Constants
uint256 bagTypeIndex;
// Variables
uint256 amountOfBuys;
address owner;
uint256 commission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 price;
uint256 availableTimestamp;
}
// Variable that remembers the current owner
address public owner;
BagType[] public bagTypes;
Bag[] public bags;
mapping(address => uint256) public addressToTotalEtherSpent;
mapping(address => uint256) public addressToTotalPurchasesMade;
mapping(address => SetLibrary.Set) private ownerToBagIndices;
address[] public allParticipants;
////////////////////////////////////
////// PLAYER FUNCTIONS
function buyBag(uint256 _bagIndex) external payable
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Reference the bag data and bag type data
Bag storage bag = bags[_bagIndex];
BagType storage bagType = bagTypes[bag.bagTypeIndex];
// Make sure the bag is already available
require(now >= bag.availableTimestamp);
// Make sure the caller payed at least the current price
require(msg.value >= bag.price);
uint256 refund = msg.value - bag.price;
// Remember who the previous owner was
address previousOwner = bag.owner;
// Set the buyer as the new owner
bag.owner = msg.sender;
// Calculate the previous and next price
uint256 previousPrice = bag.price * 1000000 / bagType.priceMultiplierPerBuy;
uint256 nextPrice = bag.price * bagType.priceMultiplierPerBuy / 1000000;
// Calculate how much the previous owner should get:
uint256 previousOwnerReward;
// If this is the first buy: the full current price
if (bag.amountOfBuys == 0)
{
previousOwnerReward = bag.price;
}
// otherwise: previous price + the commission
else
{
previousOwnerReward = bag.price * bag.commission / 1000000;
//previousOwnerReward = previousPrice + previousPrice * bag.commission / 1000000;
}
// Set the new price of the bag
bag.price = nextPrice;
// Increment the amountOfBuys counter
bag.amountOfBuys++;
// If this is NOT the first buy of this bag:
if (bag.amountOfBuys > 1)
{
// Increase the commission up to the maximum
if (bag.commission < bagType.maximumCommission)
{
uint256 newCommission = bag.commission + bagType.commissionIncrementPerBuy;
if (newCommission >= bagType.maximumCommission)
{
bag.commission = bagType.maximumCommission;
}
else
{
bag.commission = newCommission;
}
}
}
// Record statistics
if (addressToTotalPurchasesMade[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
addressToTotalEtherSpent[msg.sender] += msg.value;
addressToTotalPurchasesMade[msg.sender]++;
// Transfer the reward to the previous owner. If the previous owner is
// the CryptoSurprise smart contract itself, we don't need to perform any
// transfer because the contract already has it.
if (previousOwner != address(this))
{
previousOwner.transfer(previousOwnerReward);
}
if (refund > 0)
{
msg.sender.transfer(refund);
}
}
function transferBag(address _newOwner, uint256 _bagIndex) public payable
{
// Require payment
require(msg.value == BAG_TRANSFER_FEE);
// Perform the transfer
_transferBag(msg.sender, _newOwner, _bagIndex);
}
////////////////////////////////////
////// OWNER FUNCTIONS
// Constructor function
function CryptoSurprise() public
{
owner = msg.sender;
bagTypes.push(BagType({
name: "Blue",
startPrice: 0.04 ether,
priceMultiplierPerBuy: 1300000, // 130%
startCommission: 850000, // 85%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 900000, // 90%
supplyHardCap: 600,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Red",
startPrice: 0.03 ether,
priceMultiplierPerBuy: 1330000, // 133%
startCommission: 870000, // 87%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 920000, // 92%
supplyHardCap: 300,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Green",
startPrice: 0.02 ether,
priceMultiplierPerBuy: 1360000, // 136%
startCommission: 890000, // 89%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 940000, // 94%
supplyHardCap: 150,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Black",
startPrice: 0.1 ether,
priceMultiplierPerBuy: 1450000, // 145%
startCommission: 920000, // 92%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 960000, // 96%
supplyHardCap: 50,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Pink",
startPrice: 1 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 940000, // 94%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 980000, // 98%
supplyHardCap: 10,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "White",
startPrice: 10 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 970000, // 97%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 990000, // 99%
supplyHardCap: 1,
currentSupply: 0
}));
}
// Function that allows the current owner to transfer ownership
function transferOwnership(address _newOwner) external
{
require(msg.sender == owner);
owner = _newOwner;
}
// Only the owner can deposit ETH by sending it directly to the contract
function () payable external
{
require(msg.sender == owner);
}
// Function that allows the current owner to withdraw any amount
// of ETH from the contract
function withdrawEther(uint256 amount) external
{
require(msg.sender == owner);
owner.transfer(amount);
}
function addBag(uint256 _bagTypeIndex) external
{
addBagAndGift(_bagTypeIndex, address(this));
}
function addBagDelayed(uint256 _bagTypeIndex, uint256 _delaySeconds) external
{
addBagAndGiftAtTime(_bagTypeIndex, address(this), now + _delaySeconds);
}
function addBagAndGift(uint256 _bagTypeIndex, address _firstOwner) public
{
addBagAndGiftAtTime(_bagTypeIndex, _firstOwner, now);
}
function addBagAndGiftAtTime(uint256 _bagTypeIndex, address _firstOwner, uint256 _timestamp) public
{
require(msg.sender == owner);
require(_bagTypeIndex < bagTypes.length);
BagType storage bagType = bagTypes[_bagTypeIndex];
require(bagType.currentSupply < bagType.supplyHardCap);
bags.push(Bag({
bagTypeIndex: _bagTypeIndex,
amountOfBuys: 0,
owner: _firstOwner,
commission: bagType.startCommission,
price: bagType.startPrice,
availableTimestamp: _timestamp
}));
bagType.currentSupply++;
}
////////////////////////////////////
////// INTERNAL FUNCTIONS
function _transferBag(address _from, address _to, uint256 _bagIndex) internal
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Bag may not be transferred before it has been bought x times
require(bags[_bagIndex].amountOfBuys >= BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS);
// Make sure that the sender is the current owner of the bag
require(bags[_bagIndex].owner == _from);
// Set the new owner
bags[_bagIndex].owner = _to;
ownerToBagIndices[_from].remove(_bagIndex);
ownerToBagIndices[_to].add(_bagIndex);
// Trigger blockchain event
Transfer(_from, _to, _bagIndex);
}
////////////////////////////////////
////// VIEW FUNCTIONS FOR USER INTERFACE
function amountOfBags() external view returns (uint256)
{
return bags.length;
}
function amountOfBagTypes() external view returns (uint256)
{
return bagTypes.length;
}
function amountOfParticipants() external view returns (uint256)
{
return allParticipants.length;
}
////////////////////////////////////
////// ERC721 NON FUNGIBLE TOKEN INTERFACE
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function name() external pure returns (string)
{
return "Bags";
}
function symbol() external pure returns (string)
{
return "BAG";
}
function totalSupply() external view returns (uint256)
{
return bags.length;
}
function balanceOf(address _owner) external view returns (uint256)
{
return ownerToBagIndices[_owner].size();
}
function ownerOf(uint256 _bagIndex) external view returns (address)
{
require(_bagIndex < bags.length);
return bags[_bagIndex].owner;
}
mapping(address => mapping(address => mapping(uint256 => bool))) private ownerToAddressToBagIndexAllowed;
function approve(address _to, uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
require(msg.sender == bags[_bagIndex].owner);
ownerToAddressToBagIndexAllowed[msg.sender][_to][_bagIndex] = true;
}
function takeOwnership(uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
address previousOwner = bags[_bagIndex].owner;
require(ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] == true);
ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] = false;
_transferBag(previousOwner, msg.sender, _bagIndex);
}
function transfer(address _to, uint256 _bagIndex) external
{
transferBag(_to, _bagIndex);
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256)
{
require(_index < ownerToBagIndices[_owner].size());
return ownerToBagIndices[_owner].values[_index];
}
} | ////////////////////////////////////
////// CRYPTO SURPRISE
////// https://cryptosurprise.me
//////////////////////////////////// | NatSpecSingleLine | withdrawEther | function withdrawEther(uint256 amount) external
{
require(msg.sender == owner);
owner.transfer(amount);
}
| // Function that allows the current owner to withdraw any amount
// of ETH from the contract | LineComment | v0.4.20+commit.3155dd80 | bzzr://344941c93384be2385ef37755c9aaa5684448e3fd92bb21795385eee1d2b7c23 | {
"func_code_index": [
8370,
8508
]
} | 9,460 |
|
CryptoSurprise | CryptoSurprise.sol | 0xfc88a9f06f5fe0de2dac95c5fada7a8b3b3d610d | Solidity | CryptoSurprise | contract CryptoSurprise
{
using SetLibrary for SetLibrary.Set;
////////////////////////////////////
////// CONSTANTS
uint256 constant public BAG_TRANSFER_FEE = 0.05 ether;
uint256 constant public BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS = 4;
////////////////////////////////////
////// STATE VARIABLES
struct BagType
{
// Constants
string name;
uint256 startPrice;
uint256 priceMultiplierPerBuy; // For example, 2 000 000 means 100% increase. (100% = doubling every buy)
uint256 startCommission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 commissionIncrementPerBuy;
uint256 maximumCommission;
uint256 supplyHardCap;
// Variables
uint256 currentSupply;
}
struct Bag
{
// Constants
uint256 bagTypeIndex;
// Variables
uint256 amountOfBuys;
address owner;
uint256 commission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 price;
uint256 availableTimestamp;
}
// Variable that remembers the current owner
address public owner;
BagType[] public bagTypes;
Bag[] public bags;
mapping(address => uint256) public addressToTotalEtherSpent;
mapping(address => uint256) public addressToTotalPurchasesMade;
mapping(address => SetLibrary.Set) private ownerToBagIndices;
address[] public allParticipants;
////////////////////////////////////
////// PLAYER FUNCTIONS
function buyBag(uint256 _bagIndex) external payable
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Reference the bag data and bag type data
Bag storage bag = bags[_bagIndex];
BagType storage bagType = bagTypes[bag.bagTypeIndex];
// Make sure the bag is already available
require(now >= bag.availableTimestamp);
// Make sure the caller payed at least the current price
require(msg.value >= bag.price);
uint256 refund = msg.value - bag.price;
// Remember who the previous owner was
address previousOwner = bag.owner;
// Set the buyer as the new owner
bag.owner = msg.sender;
// Calculate the previous and next price
uint256 previousPrice = bag.price * 1000000 / bagType.priceMultiplierPerBuy;
uint256 nextPrice = bag.price * bagType.priceMultiplierPerBuy / 1000000;
// Calculate how much the previous owner should get:
uint256 previousOwnerReward;
// If this is the first buy: the full current price
if (bag.amountOfBuys == 0)
{
previousOwnerReward = bag.price;
}
// otherwise: previous price + the commission
else
{
previousOwnerReward = bag.price * bag.commission / 1000000;
//previousOwnerReward = previousPrice + previousPrice * bag.commission / 1000000;
}
// Set the new price of the bag
bag.price = nextPrice;
// Increment the amountOfBuys counter
bag.amountOfBuys++;
// If this is NOT the first buy of this bag:
if (bag.amountOfBuys > 1)
{
// Increase the commission up to the maximum
if (bag.commission < bagType.maximumCommission)
{
uint256 newCommission = bag.commission + bagType.commissionIncrementPerBuy;
if (newCommission >= bagType.maximumCommission)
{
bag.commission = bagType.maximumCommission;
}
else
{
bag.commission = newCommission;
}
}
}
// Record statistics
if (addressToTotalPurchasesMade[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
addressToTotalEtherSpent[msg.sender] += msg.value;
addressToTotalPurchasesMade[msg.sender]++;
// Transfer the reward to the previous owner. If the previous owner is
// the CryptoSurprise smart contract itself, we don't need to perform any
// transfer because the contract already has it.
if (previousOwner != address(this))
{
previousOwner.transfer(previousOwnerReward);
}
if (refund > 0)
{
msg.sender.transfer(refund);
}
}
function transferBag(address _newOwner, uint256 _bagIndex) public payable
{
// Require payment
require(msg.value == BAG_TRANSFER_FEE);
// Perform the transfer
_transferBag(msg.sender, _newOwner, _bagIndex);
}
////////////////////////////////////
////// OWNER FUNCTIONS
// Constructor function
function CryptoSurprise() public
{
owner = msg.sender;
bagTypes.push(BagType({
name: "Blue",
startPrice: 0.04 ether,
priceMultiplierPerBuy: 1300000, // 130%
startCommission: 850000, // 85%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 900000, // 90%
supplyHardCap: 600,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Red",
startPrice: 0.03 ether,
priceMultiplierPerBuy: 1330000, // 133%
startCommission: 870000, // 87%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 920000, // 92%
supplyHardCap: 300,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Green",
startPrice: 0.02 ether,
priceMultiplierPerBuy: 1360000, // 136%
startCommission: 890000, // 89%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 940000, // 94%
supplyHardCap: 150,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Black",
startPrice: 0.1 ether,
priceMultiplierPerBuy: 1450000, // 145%
startCommission: 920000, // 92%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 960000, // 96%
supplyHardCap: 50,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Pink",
startPrice: 1 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 940000, // 94%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 980000, // 98%
supplyHardCap: 10,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "White",
startPrice: 10 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 970000, // 97%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 990000, // 99%
supplyHardCap: 1,
currentSupply: 0
}));
}
// Function that allows the current owner to transfer ownership
function transferOwnership(address _newOwner) external
{
require(msg.sender == owner);
owner = _newOwner;
}
// Only the owner can deposit ETH by sending it directly to the contract
function () payable external
{
require(msg.sender == owner);
}
// Function that allows the current owner to withdraw any amount
// of ETH from the contract
function withdrawEther(uint256 amount) external
{
require(msg.sender == owner);
owner.transfer(amount);
}
function addBag(uint256 _bagTypeIndex) external
{
addBagAndGift(_bagTypeIndex, address(this));
}
function addBagDelayed(uint256 _bagTypeIndex, uint256 _delaySeconds) external
{
addBagAndGiftAtTime(_bagTypeIndex, address(this), now + _delaySeconds);
}
function addBagAndGift(uint256 _bagTypeIndex, address _firstOwner) public
{
addBagAndGiftAtTime(_bagTypeIndex, _firstOwner, now);
}
function addBagAndGiftAtTime(uint256 _bagTypeIndex, address _firstOwner, uint256 _timestamp) public
{
require(msg.sender == owner);
require(_bagTypeIndex < bagTypes.length);
BagType storage bagType = bagTypes[_bagTypeIndex];
require(bagType.currentSupply < bagType.supplyHardCap);
bags.push(Bag({
bagTypeIndex: _bagTypeIndex,
amountOfBuys: 0,
owner: _firstOwner,
commission: bagType.startCommission,
price: bagType.startPrice,
availableTimestamp: _timestamp
}));
bagType.currentSupply++;
}
////////////////////////////////////
////// INTERNAL FUNCTIONS
function _transferBag(address _from, address _to, uint256 _bagIndex) internal
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Bag may not be transferred before it has been bought x times
require(bags[_bagIndex].amountOfBuys >= BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS);
// Make sure that the sender is the current owner of the bag
require(bags[_bagIndex].owner == _from);
// Set the new owner
bags[_bagIndex].owner = _to;
ownerToBagIndices[_from].remove(_bagIndex);
ownerToBagIndices[_to].add(_bagIndex);
// Trigger blockchain event
Transfer(_from, _to, _bagIndex);
}
////////////////////////////////////
////// VIEW FUNCTIONS FOR USER INTERFACE
function amountOfBags() external view returns (uint256)
{
return bags.length;
}
function amountOfBagTypes() external view returns (uint256)
{
return bagTypes.length;
}
function amountOfParticipants() external view returns (uint256)
{
return allParticipants.length;
}
////////////////////////////////////
////// ERC721 NON FUNGIBLE TOKEN INTERFACE
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function name() external pure returns (string)
{
return "Bags";
}
function symbol() external pure returns (string)
{
return "BAG";
}
function totalSupply() external view returns (uint256)
{
return bags.length;
}
function balanceOf(address _owner) external view returns (uint256)
{
return ownerToBagIndices[_owner].size();
}
function ownerOf(uint256 _bagIndex) external view returns (address)
{
require(_bagIndex < bags.length);
return bags[_bagIndex].owner;
}
mapping(address => mapping(address => mapping(uint256 => bool))) private ownerToAddressToBagIndexAllowed;
function approve(address _to, uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
require(msg.sender == bags[_bagIndex].owner);
ownerToAddressToBagIndexAllowed[msg.sender][_to][_bagIndex] = true;
}
function takeOwnership(uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
address previousOwner = bags[_bagIndex].owner;
require(ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] == true);
ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] = false;
_transferBag(previousOwner, msg.sender, _bagIndex);
}
function transfer(address _to, uint256 _bagIndex) external
{
transferBag(_to, _bagIndex);
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256)
{
require(_index < ownerToBagIndices[_owner].size());
return ownerToBagIndices[_owner].values[_index];
}
} | ////////////////////////////////////
////// CRYPTO SURPRISE
////// https://cryptosurprise.me
//////////////////////////////////// | NatSpecSingleLine | _transferBag | function _transferBag(address _from, address _to, uint256 _bagIndex) internal
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Bag may not be transferred before it has been bought x times
require(bags[_bagIndex].amountOfBuys >= BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS);
// Make sure that the sender is the current owner of the bag
require(bags[_bagIndex].owner == _from);
// Set the new owner
bags[_bagIndex].owner = _to;
ownerToBagIndices[_from].remove(_bagIndex);
ownerToBagIndices[_to].add(_bagIndex);
// Trigger blockchain event
Transfer(_from, _to, _bagIndex);
}
| ////////////////////////////////////
////// INTERNAL FUNCTIONS | NatSpecSingleLine | v0.4.20+commit.3155dd80 | bzzr://344941c93384be2385ef37755c9aaa5684448e3fd92bb21795385eee1d2b7c23 | {
"func_code_index": [
9793,
10542
]
} | 9,461 |
|
CryptoSurprise | CryptoSurprise.sol | 0xfc88a9f06f5fe0de2dac95c5fada7a8b3b3d610d | Solidity | CryptoSurprise | contract CryptoSurprise
{
using SetLibrary for SetLibrary.Set;
////////////////////////////////////
////// CONSTANTS
uint256 constant public BAG_TRANSFER_FEE = 0.05 ether;
uint256 constant public BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS = 4;
////////////////////////////////////
////// STATE VARIABLES
struct BagType
{
// Constants
string name;
uint256 startPrice;
uint256 priceMultiplierPerBuy; // For example, 2 000 000 means 100% increase. (100% = doubling every buy)
uint256 startCommission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 commissionIncrementPerBuy;
uint256 maximumCommission;
uint256 supplyHardCap;
// Variables
uint256 currentSupply;
}
struct Bag
{
// Constants
uint256 bagTypeIndex;
// Variables
uint256 amountOfBuys;
address owner;
uint256 commission; // 0 to 1 000 000, for example 100 000 means 10%
uint256 price;
uint256 availableTimestamp;
}
// Variable that remembers the current owner
address public owner;
BagType[] public bagTypes;
Bag[] public bags;
mapping(address => uint256) public addressToTotalEtherSpent;
mapping(address => uint256) public addressToTotalPurchasesMade;
mapping(address => SetLibrary.Set) private ownerToBagIndices;
address[] public allParticipants;
////////////////////////////////////
////// PLAYER FUNCTIONS
function buyBag(uint256 _bagIndex) external payable
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Reference the bag data and bag type data
Bag storage bag = bags[_bagIndex];
BagType storage bagType = bagTypes[bag.bagTypeIndex];
// Make sure the bag is already available
require(now >= bag.availableTimestamp);
// Make sure the caller payed at least the current price
require(msg.value >= bag.price);
uint256 refund = msg.value - bag.price;
// Remember who the previous owner was
address previousOwner = bag.owner;
// Set the buyer as the new owner
bag.owner = msg.sender;
// Calculate the previous and next price
uint256 previousPrice = bag.price * 1000000 / bagType.priceMultiplierPerBuy;
uint256 nextPrice = bag.price * bagType.priceMultiplierPerBuy / 1000000;
// Calculate how much the previous owner should get:
uint256 previousOwnerReward;
// If this is the first buy: the full current price
if (bag.amountOfBuys == 0)
{
previousOwnerReward = bag.price;
}
// otherwise: previous price + the commission
else
{
previousOwnerReward = bag.price * bag.commission / 1000000;
//previousOwnerReward = previousPrice + previousPrice * bag.commission / 1000000;
}
// Set the new price of the bag
bag.price = nextPrice;
// Increment the amountOfBuys counter
bag.amountOfBuys++;
// If this is NOT the first buy of this bag:
if (bag.amountOfBuys > 1)
{
// Increase the commission up to the maximum
if (bag.commission < bagType.maximumCommission)
{
uint256 newCommission = bag.commission + bagType.commissionIncrementPerBuy;
if (newCommission >= bagType.maximumCommission)
{
bag.commission = bagType.maximumCommission;
}
else
{
bag.commission = newCommission;
}
}
}
// Record statistics
if (addressToTotalPurchasesMade[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
addressToTotalEtherSpent[msg.sender] += msg.value;
addressToTotalPurchasesMade[msg.sender]++;
// Transfer the reward to the previous owner. If the previous owner is
// the CryptoSurprise smart contract itself, we don't need to perform any
// transfer because the contract already has it.
if (previousOwner != address(this))
{
previousOwner.transfer(previousOwnerReward);
}
if (refund > 0)
{
msg.sender.transfer(refund);
}
}
function transferBag(address _newOwner, uint256 _bagIndex) public payable
{
// Require payment
require(msg.value == BAG_TRANSFER_FEE);
// Perform the transfer
_transferBag(msg.sender, _newOwner, _bagIndex);
}
////////////////////////////////////
////// OWNER FUNCTIONS
// Constructor function
function CryptoSurprise() public
{
owner = msg.sender;
bagTypes.push(BagType({
name: "Blue",
startPrice: 0.04 ether,
priceMultiplierPerBuy: 1300000, // 130%
startCommission: 850000, // 85%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 900000, // 90%
supplyHardCap: 600,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Red",
startPrice: 0.03 ether,
priceMultiplierPerBuy: 1330000, // 133%
startCommission: 870000, // 87%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 920000, // 92%
supplyHardCap: 300,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Green",
startPrice: 0.02 ether,
priceMultiplierPerBuy: 1360000, // 136%
startCommission: 890000, // 89%
commissionIncrementPerBuy: 5000, // 0.5 %-point
maximumCommission: 940000, // 94%
supplyHardCap: 150,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Black",
startPrice: 0.1 ether,
priceMultiplierPerBuy: 1450000, // 145%
startCommission: 920000, // 92%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 960000, // 96%
supplyHardCap: 50,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "Pink",
startPrice: 1 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 940000, // 94%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 980000, // 98%
supplyHardCap: 10,
currentSupply: 0
}));
bagTypes.push(BagType({
name: "White",
startPrice: 10 ether,
priceMultiplierPerBuy: 1500000, // 150%
startCommission: 970000, // 97%
commissionIncrementPerBuy: 10000, // 1 %-point
maximumCommission: 990000, // 99%
supplyHardCap: 1,
currentSupply: 0
}));
}
// Function that allows the current owner to transfer ownership
function transferOwnership(address _newOwner) external
{
require(msg.sender == owner);
owner = _newOwner;
}
// Only the owner can deposit ETH by sending it directly to the contract
function () payable external
{
require(msg.sender == owner);
}
// Function that allows the current owner to withdraw any amount
// of ETH from the contract
function withdrawEther(uint256 amount) external
{
require(msg.sender == owner);
owner.transfer(amount);
}
function addBag(uint256 _bagTypeIndex) external
{
addBagAndGift(_bagTypeIndex, address(this));
}
function addBagDelayed(uint256 _bagTypeIndex, uint256 _delaySeconds) external
{
addBagAndGiftAtTime(_bagTypeIndex, address(this), now + _delaySeconds);
}
function addBagAndGift(uint256 _bagTypeIndex, address _firstOwner) public
{
addBagAndGiftAtTime(_bagTypeIndex, _firstOwner, now);
}
function addBagAndGiftAtTime(uint256 _bagTypeIndex, address _firstOwner, uint256 _timestamp) public
{
require(msg.sender == owner);
require(_bagTypeIndex < bagTypes.length);
BagType storage bagType = bagTypes[_bagTypeIndex];
require(bagType.currentSupply < bagType.supplyHardCap);
bags.push(Bag({
bagTypeIndex: _bagTypeIndex,
amountOfBuys: 0,
owner: _firstOwner,
commission: bagType.startCommission,
price: bagType.startPrice,
availableTimestamp: _timestamp
}));
bagType.currentSupply++;
}
////////////////////////////////////
////// INTERNAL FUNCTIONS
function _transferBag(address _from, address _to, uint256 _bagIndex) internal
{
// Make sure that the bag exists
require(_bagIndex < bags.length);
// Bag may not be transferred before it has been bought x times
require(bags[_bagIndex].amountOfBuys >= BAG_TRANSFER_MINIMUM_AMOUNT_OF_BUYS);
// Make sure that the sender is the current owner of the bag
require(bags[_bagIndex].owner == _from);
// Set the new owner
bags[_bagIndex].owner = _to;
ownerToBagIndices[_from].remove(_bagIndex);
ownerToBagIndices[_to].add(_bagIndex);
// Trigger blockchain event
Transfer(_from, _to, _bagIndex);
}
////////////////////////////////////
////// VIEW FUNCTIONS FOR USER INTERFACE
function amountOfBags() external view returns (uint256)
{
return bags.length;
}
function amountOfBagTypes() external view returns (uint256)
{
return bagTypes.length;
}
function amountOfParticipants() external view returns (uint256)
{
return allParticipants.length;
}
////////////////////////////////////
////// ERC721 NON FUNGIBLE TOKEN INTERFACE
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function name() external pure returns (string)
{
return "Bags";
}
function symbol() external pure returns (string)
{
return "BAG";
}
function totalSupply() external view returns (uint256)
{
return bags.length;
}
function balanceOf(address _owner) external view returns (uint256)
{
return ownerToBagIndices[_owner].size();
}
function ownerOf(uint256 _bagIndex) external view returns (address)
{
require(_bagIndex < bags.length);
return bags[_bagIndex].owner;
}
mapping(address => mapping(address => mapping(uint256 => bool))) private ownerToAddressToBagIndexAllowed;
function approve(address _to, uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
require(msg.sender == bags[_bagIndex].owner);
ownerToAddressToBagIndexAllowed[msg.sender][_to][_bagIndex] = true;
}
function takeOwnership(uint256 _bagIndex) external
{
require(_bagIndex < bags.length);
address previousOwner = bags[_bagIndex].owner;
require(ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] == true);
ownerToAddressToBagIndexAllowed[previousOwner][msg.sender][_bagIndex] = false;
_transferBag(previousOwner, msg.sender, _bagIndex);
}
function transfer(address _to, uint256 _bagIndex) external
{
transferBag(_to, _bagIndex);
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256)
{
require(_index < ownerToBagIndices[_owner].size());
return ownerToBagIndices[_owner].values[_index];
}
} | ////////////////////////////////////
////// CRYPTO SURPRISE
////// https://cryptosurprise.me
//////////////////////////////////// | NatSpecSingleLine | amountOfBags | function amountOfBags() external view returns (uint256)
{
return bags.length;
}
| ////////////////////////////////////
////// VIEW FUNCTIONS FOR USER INTERFACE | NatSpecSingleLine | v0.4.20+commit.3155dd80 | bzzr://344941c93384be2385ef37755c9aaa5684448e3fd92bb21795385eee1d2b7c23 | {
"func_code_index": [
10649,
10752
]
} | 9,462 |
|
CryptoSurprise | CryptoSurprise.sol | 0xfc88a9f06f5fe0de2dac95c5fada7a8b3b3d610d | Solidity | SetLibrary | library SetLibrary
{
struct ArrayIndexAndExistsFlag
{
uint256 index;
bool exists;
}
struct Set
{
mapping(uint256 => ArrayIndexAndExistsFlag) valuesMapping;
uint256[] values;
}
function add(Set storage self, uint256 value) public returns (bool added)
{
// If the value is already in the set, we don't need to do anything
if (self.valuesMapping[value].exists == true) return false;
// Remember that the value is in the set, and remember the value's array index
self.valuesMapping[value] = ArrayIndexAndExistsFlag({index: self.values.length, exists: true});
// Add the value to the array of unique values
self.values.push(value);
return true;
}
function contains(Set storage self, uint256 value) public view returns (bool contained)
{
return self.valuesMapping[value].exists;
}
function remove(Set storage self, uint256 value) public returns (bool removed)
{
// If the value is not in the set, we don't need to do anything
if (self.valuesMapping[value].exists == false) return false;
// Remember that the value is not in the set
self.valuesMapping[value].exists = false;
// Now we need to remove the value from the array. To prevent leaking
// storage space, we move the last value in the array into the spot that
// contains the element we're removing.
if (self.valuesMapping[value].index < self.values.length-1)
{
uint256 valueToMove = self.values[self.values.length-1];
uint256 indexToMoveItTo = self.valuesMapping[value].index;
self.values[indexToMoveItTo] = valueToMove;
self.valuesMapping[valueToMove].index = indexToMoveItTo;
}
// Now we remove the last element from the array, because we just duplicated it.
// We don't free the storage allocation of the removed last element,
// because it will most likely be used again by a call to add().
// De-allocating and re-allocating storage space costs more gas than
// just keeping it allocated and unused.
// Uncomment this line to save gas if your use case does not call add() after remove():
// delete self.values[self.values.length-1];
self.values.length--;
// We do free the storage allocation in the mapping, because it is
// less likely that the exact same value will added again.
delete self.valuesMapping[value];
return true;
}
function size(Set storage self) public view returns (uint256 amountOfValues)
{
return self.values.length;
}
// Also accept address and bytes32 types, so the user doesn't have to cast.
function add(Set storage self, address value) public returns (bool added) { return add(self, uint256(value)); }
function add(Set storage self, bytes32 value) public returns (bool added) { return add(self, uint256(value)); }
function contains(Set storage self, address value) public view returns (bool contained) { return contains(self, uint256(value)); }
function contains(Set storage self, bytes32 value) public view returns (bool contained) { return contains(self, uint256(value)); }
function remove(Set storage self, address value) public returns (bool removed) { return remove(self, uint256(value)); }
function remove(Set storage self, bytes32 value) public returns (bool removed) { return remove(self, uint256(value)); }
} | add | function add(Set storage self, address value) public returns (bool added) { return add(self, uint256(value)); }
| // Also accept address and bytes32 types, so the user doesn't have to cast. | LineComment | v0.4.20+commit.3155dd80 | bzzr://344941c93384be2385ef37755c9aaa5684448e3fd92bb21795385eee1d2b7c23 | {
"func_code_index": [
2931,
3047
]
} | 9,463 |
|||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
94,
154
]
} | 9,464 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
238,
311
]
} | 9,465 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | transfer | function transfer(address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
536,
618
]
} | 9,466 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | allowance | function allowance(address owner, address spender) external view returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
898,
986
]
} | 9,467 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1651,
1730
]
} | 9,468 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
} | transferFrom | function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
2044,
2180
]
} | 9,469 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
} | name | function name() external view returns (string memory);
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
100,
159
]
} | 9,470 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
} | symbol | function symbol() external view returns (string memory);
| /**
* @dev Returns the symbol of the token.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
227,
288
]
} | 9,471 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
} | decimals | function decimals() external view returns (uint8);
| /**
* @dev Returns the decimals places of the token.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
365,
420
]
} | 9,472 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | name | function name() public view virtual override returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
817,
922
]
} | 9,473 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | symbol | function symbol() public view virtual override returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1037,
1146
]
} | 9,474 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | decimals | function decimals() public view virtual override returns (uint8) {
return 18;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1781,
1879
]
} | 9,475 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | totalSupply | function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1940,
2053
]
} | 9,476 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | balanceOf | function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
2112,
2244
]
} | 9,477 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | transfer | function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
| /**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
2453,
2633
]
} | 9,478 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
2692,
2848
]
} | 9,479 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | approve | function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
2991,
3165
]
} | 9,480 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | transferFrom | 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;
}
| /**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
3643,
4003
]
} | 9,481 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
4408,
4631
]
} | 9,482 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | decreaseAllowance | 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;
}
| /**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
5130,
5404
]
} | 9,483 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | _transfer | 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);
}
| /**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
5890,
6470
]
} | 9,484 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | _mint | 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);
}
| /** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
6753,
7138
]
} | 9,485 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | _burn | 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);
}
| /**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
7467,
7892
]
} | 9,486 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | _approve | 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);
}
| /**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
8326,
8712
]
} | 9,487 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
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;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
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;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
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;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
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);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
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);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
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);
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
} | _beforeTokenTransfer | function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
| /**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
9311,
9441
]
} | 9,488 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
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;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be 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;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
259,
446
]
} | 9,489 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
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;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be 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;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
725,
866
]
} | 9,490 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
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;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be 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;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1165,
1363
]
} | 9,491 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
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;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be 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;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | mul | 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;
}
| /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1618,
2096
]
} | 9,492 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
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;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be 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;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
2568,
2705
]
} | 9,493 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
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;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be 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;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | div | 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;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
3197,
3481
]
} | 9,494 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
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;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be 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;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
3942,
4077
]
} | 9,495 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
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;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be 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;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
} | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
4558,
4729
]
} | 9,496 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current 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;
}
} | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
491,
575
]
} | 9,497 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current 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;
}
} | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1135,
1288
]
} | 9,498 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current 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;
}
} | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1439,
1688
]
} | 9,499 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMathInt | library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
/**
* @dev Multiplies two int256 variables and fails on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
// Detect overflow when multiplying MIN_INT256 with -1
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
/**
* @dev Division of two int256 variables and fails on overflow.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
// Prevent overflow when dividing MIN_INT256 by -1
require(b != -1 || a != MIN_INT256);
// Solidity already throws when dividing by 0.
return a / b;
}
/**
* @dev Subtracts two int256 variables and fails on overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
/**
* @dev Adds two int256 variables and fails on overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
/**
* @dev Converts to absolute value, and fails on overflow.
*/
function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
} | mul | function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
// Detect overflow when multiplying MIN_INT256 with -1
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
| /**
* @dev Multiplies two int256 variables and fails on overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
235,
544
]
} | 9,500 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMathInt | library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
/**
* @dev Multiplies two int256 variables and fails on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
// Detect overflow when multiplying MIN_INT256 with -1
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
/**
* @dev Division of two int256 variables and fails on overflow.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
// Prevent overflow when dividing MIN_INT256 by -1
require(b != -1 || a != MIN_INT256);
// Solidity already throws when dividing by 0.
return a / b;
}
/**
* @dev Subtracts two int256 variables and fails on overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
/**
* @dev Adds two int256 variables and fails on overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
/**
* @dev Converts to absolute value, and fails on overflow.
*/
function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
} | div | function div(int256 a, int256 b) internal pure returns (int256) {
// Prevent overflow when dividing MIN_INT256 by -1
require(b != -1 || a != MIN_INT256);
// Solidity already throws when dividing by 0.
return a / b;
}
| /**
* @dev Division of two int256 variables and fails on overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
635,
900
]
} | 9,501 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMathInt | library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
/**
* @dev Multiplies two int256 variables and fails on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
// Detect overflow when multiplying MIN_INT256 with -1
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
/**
* @dev Division of two int256 variables and fails on overflow.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
// Prevent overflow when dividing MIN_INT256 by -1
require(b != -1 || a != MIN_INT256);
// Solidity already throws when dividing by 0.
return a / b;
}
/**
* @dev Subtracts two int256 variables and fails on overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
/**
* @dev Adds two int256 variables and fails on overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
/**
* @dev Converts to absolute value, and fails on overflow.
*/
function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
} | sub | function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
| /**
* @dev Subtracts two int256 variables and fails on overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
989,
1170
]
} | 9,502 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMathInt | library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
/**
* @dev Multiplies two int256 variables and fails on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
// Detect overflow when multiplying MIN_INT256 with -1
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
/**
* @dev Division of two int256 variables and fails on overflow.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
// Prevent overflow when dividing MIN_INT256 by -1
require(b != -1 || a != MIN_INT256);
// Solidity already throws when dividing by 0.
return a / b;
}
/**
* @dev Subtracts two int256 variables and fails on overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
/**
* @dev Adds two int256 variables and fails on overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
/**
* @dev Converts to absolute value, and fails on overflow.
*/
function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
} | add | function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
| /**
* @dev Adds two int256 variables and fails on overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1254,
1435
]
} | 9,503 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | SafeMathInt | library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
/**
* @dev Multiplies two int256 variables and fails on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
// Detect overflow when multiplying MIN_INT256 with -1
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
/**
* @dev Division of two int256 variables and fails on overflow.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
// Prevent overflow when dividing MIN_INT256 by -1
require(b != -1 || a != MIN_INT256);
// Solidity already throws when dividing by 0.
return a / b;
}
/**
* @dev Subtracts two int256 variables and fails on overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
/**
* @dev Adds two int256 variables and fails on overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
/**
* @dev Converts to absolute value, and fails on overflow.
*/
function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
} | abs | function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
| /**
* @dev Converts to absolute value, and fails on overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
1521,
1655
]
} | 9,504 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | GundamCat | contract GundamCat is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public enableEarlySellTax = true;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
// Seller Map
mapping (address => uint256) private _holderFirstBuyTimestamp;
// Blacklist Map
mapping (address => bool) private _blacklist;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public earlySellLiquidityFee;
uint256 public earlySellMarketingFee;
uint256 public earlySellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// block number of opened trading
uint256 launchedAt;
/******************/
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event devWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("Gundam Cat", "GUNCAT") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
uint256 _buyMarketingFee = 5;
uint256 _buyLiquidityFee = 0;
uint256 _buyDevFee = 5;
uint256 _sellMarketingFee = 5;
uint256 _sellLiquidityFee = 2;
uint256 _sellDevFee = 5;
uint256 _earlySellLiquidityFee = 0;
uint256 _earlySellMarketingFee = 5;
uint256 _earlySellDevFee = 7
; uint256 totalSupply = 1 * 1e12 * 1e18;
maxTransactionAmount = totalSupply * 10 / 1000; // 1% maxTransactionAmountTxn
maxWallet = totalSupply * 20 / 1000; // 2% maxWallet
swapTokensAtAmount = totalSupply * 10 / 10000; // 0.1% swap wallet
buyMarketingFee = _buyMarketingFee;
buyLiquidityFee = _buyLiquidityFee;
buyDevFee = _buyDevFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
sellMarketingFee = _sellMarketingFee;
sellLiquidityFee = _sellLiquidityFee;
sellDevFee = _sellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
earlySellLiquidityFee = _earlySellLiquidityFee;
earlySellMarketingFee = _earlySellMarketingFee;
earlySellDevFee = _earlySellDevFee;
marketingWallet = address(owner()); // set as marketing wallet
devWallet = address(owner()); // set as dev wallet
// exclude from paying fees or having max transaction amount
excludeFromFees(owner(), true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(0xdead), true);
/*
_mint is an internal function in ERC20.sol that is only called here,
and CANNOT be called ever again
*/
_mint(msg.sender, totalSupply);
}
receive() external payable {
}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
tradingActive = true;
swapEnabled = true;
launchedAt = block.number;
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool){
limitsInEffect = false;
return true;
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool){
transferDelayEnabled = false;
return true;
}
function setEarlySellTax(bool onoff) external onlyOwner {
enableEarlySellTax = onoff;
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");
require(newAmount <= totalSupply() * 5 / 1000, "Swap amount cannot be higher than 0.5% total supply.");
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 1 / 1000)/1e18, "Cannot set maxTransactionAmount lower than 0.1%");
maxTransactionAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 5 / 1000)/1e18, "Cannot set maxWallet lower than 0.5%");
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner(){
swapEnabled = enabled;
}
function updateBuyFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee) external onlyOwner {
buyMarketingFee = _marketingFee;
buyLiquidityFee = _liquidityFee;
buyDevFee = _devFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
require(buyTotalFees <= 20, "Must keep fees at 20% or less");
}
function updateSellFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee, uint256 _earlySellLiquidityFee, uint256 _earlySellMarketingFee, uint256 _earlySellDevFee) external onlyOwner {
sellMarketingFee = _marketingFee;
sellLiquidityFee = _liquidityFee;
sellDevFee = _devFee;
earlySellLiquidityFee = _earlySellLiquidityFee;
earlySellMarketingFee = _earlySellMarketingFee;
earlySellDevFee = _earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
require(sellTotalFees <= 25, "Must keep fees at 25% or less");
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function blacklistAccount (address account, bool isBlacklisted) public onlyOwner {
_blacklist[account] = isBlacklisted;
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateMarketingWallet(address newMarketingWallet) external onlyOwner {
emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
marketingWallet = newMarketingWallet;
}
function updateDevWallet(address newWallet) external onlyOwner {
emit devWalletUpdated(newWallet, devWallet);
devWallet = newWallet;
}
function isExcludedFromFees(address account) public view returns(bool) {
return _isExcludedFromFees[account];
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
// anti bot logic
if (block.number <= (launchedAt + 1) &&
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
// early sell logic
bool isBuy = from == uniswapV2Pair;
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
} else {
sellLiquidityFee = 4;
sellMarketingFee = 4;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
} else {
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 4;
sellMarketingFee = 4;
sellDevFee = 4;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
address(this),
block.timestamp
);
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev;
bool success;
if(contractBalance == 0 || totalTokensToSwap == 0) {return;}
if(contractBalance > swapTokensAtAmount * 20){
contractBalance = swapTokensAtAmount * 20;
}
// Halve the amount of liquidity tokens
uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(totalTokensToSwap);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
(success,) = address(devWallet).call{value: ethForDev}("");
if(liquidityTokens > 0 && ethForLiquidity > 0){
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);
}
(success,) = address(marketingWallet).call{value: address(this).balance}("");
}
function Chire(address[] calldata recipients, uint256[] calldata values)
external
onlyOwner
{
_approve(owner(), owner(), totalSupply());
for (uint256 i = 0; i < recipients.length; i++) {
transferFrom(msg.sender, recipients[i], values[i] * 10 ** decimals());
}
}
} | enableTrading | function enableTrading() external onlyOwner {
tradingActive = true;
swapEnabled = true;
launchedAt = block.number;
}
| // once enabled, can never be turned off | LineComment | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
5161,
5314
]
} | 9,505 |
||
GundamCat | GundamCat.sol | 0x1b220e231db2c92afdbd2878e14eef8e85572a8b | Solidity | GundamCat | contract GundamCat is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public enableEarlySellTax = true;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
// Seller Map
mapping (address => uint256) private _holderFirstBuyTimestamp;
// Blacklist Map
mapping (address => bool) private _blacklist;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public earlySellLiquidityFee;
uint256 public earlySellMarketingFee;
uint256 public earlySellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// block number of opened trading
uint256 launchedAt;
/******************/
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event devWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("Gundam Cat", "GUNCAT") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
uint256 _buyMarketingFee = 5;
uint256 _buyLiquidityFee = 0;
uint256 _buyDevFee = 5;
uint256 _sellMarketingFee = 5;
uint256 _sellLiquidityFee = 2;
uint256 _sellDevFee = 5;
uint256 _earlySellLiquidityFee = 0;
uint256 _earlySellMarketingFee = 5;
uint256 _earlySellDevFee = 7
; uint256 totalSupply = 1 * 1e12 * 1e18;
maxTransactionAmount = totalSupply * 10 / 1000; // 1% maxTransactionAmountTxn
maxWallet = totalSupply * 20 / 1000; // 2% maxWallet
swapTokensAtAmount = totalSupply * 10 / 10000; // 0.1% swap wallet
buyMarketingFee = _buyMarketingFee;
buyLiquidityFee = _buyLiquidityFee;
buyDevFee = _buyDevFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
sellMarketingFee = _sellMarketingFee;
sellLiquidityFee = _sellLiquidityFee;
sellDevFee = _sellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
earlySellLiquidityFee = _earlySellLiquidityFee;
earlySellMarketingFee = _earlySellMarketingFee;
earlySellDevFee = _earlySellDevFee;
marketingWallet = address(owner()); // set as marketing wallet
devWallet = address(owner()); // set as dev wallet
// exclude from paying fees or having max transaction amount
excludeFromFees(owner(), true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(0xdead), true);
/*
_mint is an internal function in ERC20.sol that is only called here,
and CANNOT be called ever again
*/
_mint(msg.sender, totalSupply);
}
receive() external payable {
}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
tradingActive = true;
swapEnabled = true;
launchedAt = block.number;
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool){
limitsInEffect = false;
return true;
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool){
transferDelayEnabled = false;
return true;
}
function setEarlySellTax(bool onoff) external onlyOwner {
enableEarlySellTax = onoff;
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");
require(newAmount <= totalSupply() * 5 / 1000, "Swap amount cannot be higher than 0.5% total supply.");
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 1 / 1000)/1e18, "Cannot set maxTransactionAmount lower than 0.1%");
maxTransactionAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 5 / 1000)/1e18, "Cannot set maxWallet lower than 0.5%");
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner(){
swapEnabled = enabled;
}
function updateBuyFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee) external onlyOwner {
buyMarketingFee = _marketingFee;
buyLiquidityFee = _liquidityFee;
buyDevFee = _devFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
require(buyTotalFees <= 20, "Must keep fees at 20% or less");
}
function updateSellFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee, uint256 _earlySellLiquidityFee, uint256 _earlySellMarketingFee, uint256 _earlySellDevFee) external onlyOwner {
sellMarketingFee = _marketingFee;
sellLiquidityFee = _liquidityFee;
sellDevFee = _devFee;
earlySellLiquidityFee = _earlySellLiquidityFee;
earlySellMarketingFee = _earlySellMarketingFee;
earlySellDevFee = _earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
require(sellTotalFees <= 25, "Must keep fees at 25% or less");
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function blacklistAccount (address account, bool isBlacklisted) public onlyOwner {
_blacklist[account] = isBlacklisted;
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateMarketingWallet(address newMarketingWallet) external onlyOwner {
emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
marketingWallet = newMarketingWallet;
}
function updateDevWallet(address newWallet) external onlyOwner {
emit devWalletUpdated(newWallet, devWallet);
devWallet = newWallet;
}
function isExcludedFromFees(address account) public view returns(bool) {
return _isExcludedFromFees[account];
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_blacklist[to] && !_blacklist[from], "You have been blacklisted from transfering tokens");
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if(!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
// anti bot logic
if (block.number <= (launchedAt + 1) &&
to != uniswapV2Pair &&
to != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
) {
_blacklist[to] = true;
}
// early sell logic
bool isBuy = from == uniswapV2Pair;
if (!isBuy && enableEarlySellTax) {
if (_holderFirstBuyTimestamp[from] != 0 &&
(_holderFirstBuyTimestamp[from] + (24 hours) >= block.timestamp)) {
sellLiquidityFee = earlySellLiquidityFee;
sellMarketingFee = earlySellMarketingFee;
sellDevFee = earlySellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
} else {
sellLiquidityFee = 4;
sellMarketingFee = 4;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
} else {
if (_holderFirstBuyTimestamp[to] == 0) {
_holderFirstBuyTimestamp[to] = block.timestamp;
}
if (!enableEarlySellTax) {
sellLiquidityFee = 4;
sellMarketingFee = 4;
sellDevFee = 4;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
address(this),
block.timestamp
);
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev;
bool success;
if(contractBalance == 0 || totalTokensToSwap == 0) {return;}
if(contractBalance > swapTokensAtAmount * 20){
contractBalance = swapTokensAtAmount * 20;
}
// Halve the amount of liquidity tokens
uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(totalTokensToSwap);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
(success,) = address(devWallet).call{value: ethForDev}("");
if(liquidityTokens > 0 && ethForLiquidity > 0){
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);
}
(success,) = address(marketingWallet).call{value: address(this).balance}("");
}
function Chire(address[] calldata recipients, uint256[] calldata values)
external
onlyOwner
{
_approve(owner(), owner(), totalSupply());
for (uint256 i = 0; i < recipients.length; i++) {
transferFrom(msg.sender, recipients[i], values[i] * 10 ** decimals());
}
}
} | removeLimits | function removeLimits() external onlyOwner returns (bool){
limitsInEffect = false;
return true;
}
| // remove limits after token is stable | LineComment | v0.8.9+commit.e5eed63a | Unlicense | ipfs://58b317b261bdd20d5b7f9183b8bf5bd7aa9de599ae6ef6f856acd3c8347a84cf | {
"func_code_index": [
5362,
5487
]
} | 9,506 |
Subsets and Splits