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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
updateDefaultExtensionAddress
|
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
|
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
3196,
3437
]
}
| 58,861
|
||
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
updateLiquidityFarmTokenCollectionURI
|
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
|
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
3627,
3825
]
}
| 58,862
|
||
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
updateLiquidityFarmTokenURI
|
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
|
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
4005,
4163
]
}
| 58,863
|
||
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
getLiquidityFarmTokenCollectionURI
|
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
|
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
4292,
4445
]
}
| 58,864
|
||
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
getLiquidityFarmTokenURI
|
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
|
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
4552,
4685
]
}
| 58,865
|
||
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
cloneLiquidityMiningDefaultExtension
|
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
|
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
4846,
5046
]
}
| 58,866
|
||
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
deploy
|
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
|
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
5438,
5743
]
}
| 58,867
|
||
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
_clone
|
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
|
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
5978,
6482
]
}
| 58,868
|
||
LiquidityMiningFactory
|
contracts\liquidity-mining\LiquidityMiningFactory.sol
|
0x9df4e915d093f03169270857cf9a0a5d1ef26388
|
Solidity
|
LiquidityMiningFactory
|
contract LiquidityMiningFactory is ILiquidityMiningFactory {
// liquidity mining contract implementation address
address public liquidityMiningImplementationAddress;
// liquidity mining default extension
address public override liquidityMiningDefaultExtension;
// double proxy address of the linked DFO
address public _doubleProxy;
// linked DFO exit fee
uint256 private _feePercentage;
// liquidity mining collection uri
string public liquidityFarmTokenCollectionURI;
// liquidity mining farm token uri
string public liquidityFarmTokenURI;
// event that tracks liquidity mining contracts deployed
event LiquidityMiningDeployed(address indexed liquidityMiningAddress, address indexed sender, bytes liquidityMiningInitResultData);
// event that tracks logic contract address change
event LiquidityMiningLogicSet(address indexed newAddress);
// event that tracks default extension contract address change
event LiquidityMiningDefaultExtensionSet(address indexed newAddress);
// event that tracks wallet changes
event FeePercentageSet(uint256 newFeePercentage);
constructor(address doubleProxy, address _liquidityMiningImplementationAddress, address _liquidityMiningDefaultExtension, uint256 feePercentage, string memory liquidityFarmTokenCollectionUri, string memory liquidityFarmTokenUri) {
_doubleProxy = doubleProxy;
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
liquidityFarmTokenURI = liquidityFarmTokenUri;
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtension);
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** PUBLIC METHODS */
function feePercentageInfo() public override view returns (uint256, address) {
return (_feePercentage, IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDWalletAddress());
}
/** @dev allows the DFO to update the double proxy address.
* @param newDoubleProxy new double proxy address.
*/
function setDoubleProxy(address newDoubleProxy) public onlyDFO {
_doubleProxy = newDoubleProxy;
}
/** @dev change the fee percentage
* @param feePercentage new fee percentage.
*/
function updateFeePercentage(uint256 feePercentage) public onlyDFO {
emit FeePercentageSet(_feePercentage = feePercentage);
}
/** @dev allows the factory owner to update the logic contract address.
* @param _liquidityMiningImplementationAddress new liquidity mining implementation address.
*/
function updateLogicAddress(address _liquidityMiningImplementationAddress) public onlyDFO {
emit LiquidityMiningLogicSet(liquidityMiningImplementationAddress = _liquidityMiningImplementationAddress);
}
/** @dev allows the factory owner to update the default extension contract address.
* @param _liquidityMiningDefaultExtensionAddress new liquidity mining extension address.
*/
function updateDefaultExtensionAddress(address _liquidityMiningDefaultExtensionAddress) public onlyDFO {
emit LiquidityMiningDefaultExtensionSet(liquidityMiningDefaultExtension = _liquidityMiningDefaultExtensionAddress);
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenCollectionUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenCollectionURI(string memory liquidityFarmTokenCollectionUri) public onlyDFO {
liquidityFarmTokenCollectionURI = liquidityFarmTokenCollectionUri;
}
/** @dev allows the factory owner to update the liquidity farm token collection uri.
* @param liquidityFarmTokenUri new liquidity farm token collection uri.
*/
function updateLiquidityFarmTokenURI(string memory liquidityFarmTokenUri) public onlyDFO {
liquidityFarmTokenURI = liquidityFarmTokenUri;
}
/** @dev returns the liquidity farm token collection uri.
* @return liquidity farm token collection uri.
*/
function getLiquidityFarmTokenCollectionURI() public override view returns (string memory) {
return liquidityFarmTokenCollectionURI;
}
/** @dev returns the liquidity farm token uri.
* @return liquidity farm token uri.
*/
function getLiquidityFarmTokenURI() public override view returns (string memory) {
return liquidityFarmTokenURI;
}
/** @dev utlity method to clone default extension
* @return clonedExtension the address of the actually-cloned liquidity mining extension
*/
function cloneLiquidityMiningDefaultExtension() public override returns(address clonedExtension) {
emit ExtensionCloned(clonedExtension = _clone(liquidityMiningDefaultExtension));
}
/** @dev this function deploys a new LiquidityMining contract and calls the encoded function passed as data.
* @param data encoded initialize function for the liquidity mining contract (check LiquidityMining contract code).
* @return contractAddress new liquidity mining contract address.
* @return initResultData new liquidity mining contract call result.
*/
function deploy(bytes memory data) public returns (address contractAddress, bytes memory initResultData) {
initResultData = _call(contractAddress = _clone(liquidityMiningImplementationAddress), data);
emit LiquidityMiningDeployed(contractAddress, msg.sender, initResultData);
}
/** PRIVATE METHODS */
/** @dev clones the input contract address and returns the copied contract address.
* @param original address of the original contract.
* @return copy copied contract address.
*/
function _clone(address original) private returns (address copy) {
assembly {
mstore(
0,
or(
0x5880730000000000000000000000000000000000000000803b80938091923cF3,
mul(original, 0x1000000000000000000)
)
)
copy := create(0, 0, 32)
switch extcodesize(copy)
case 0 {
invalid()
}
}
}
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
/** @dev onlyDFO modifier used to check for unauthorized accesses. */
modifier onlyDFO() {
require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized.");
_;
}
}
|
_call
|
function _call(address location, bytes memory payload) private returns(bytes memory returnData) {
assembly {
let result := call(gas(), location, 0, add(payload, 0x20), mload(payload), 0, 0)
let size := returndatasize()
returnData := mload(0x40)
mstore(returnData, size)
let returnDataPayloadStart := add(returnData, 0x20)
returndatacopy(returnDataPayloadStart, 0, size)
mstore(0x40, add(returnDataPayloadStart, size))
switch result case 0 {revert(returnDataPayloadStart, size)}
}
}
|
/** @dev calls the contract at the given location using the given payload and returns the returnData.
* @param location location to call.
* @param payload call payload.
* @return returnData call return data.
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
MIT
|
ipfs://f058c01d1a28d1984b20f4a56b451c5333cbb324fde2ceba602ca7e5b331c64a
|
{
"func_code_index": [
6728,
7341
]
}
| 58,869
|
||
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
IOwned
|
contract IOwned {
// this function isn't abstract since the compiler emits automatically generated getter functions as external
function owner() public constant returns (address owner) { owner; }
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
|
/*
Owned contract interface
*/
|
Comment
|
owner
|
function owner() public constant returns (address owner) { owner; }
|
// this function isn't abstract since the compiler emits automatically generated getter functions as external
|
LineComment
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
134,
206
]
}
| 58,870
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
Owned
|
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address _prevOwner, address _newOwner);
/**
@dev constructor
*/
function Owned() {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
/**
@dev allows transferring the contract ownership
the new owner still need to accept the transfer
can only be called by the contract owner
@param _newOwner new contract owner
*/
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
/**
@dev used by a new owner to accept an ownership transfer
*/
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
|
/*
Provides support and utilities for contract ownership
*/
|
Comment
|
Owned
|
function Owned() {
owner = msg.sender;
}
|
/**
@dev constructor
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
195,
254
]
}
| 58,871
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
Owned
|
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address _prevOwner, address _newOwner);
/**
@dev constructor
*/
function Owned() {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
/**
@dev allows transferring the contract ownership
the new owner still need to accept the transfer
can only be called by the contract owner
@param _newOwner new contract owner
*/
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
/**
@dev used by a new owner to accept an ownership transfer
*/
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
|
/*
Provides support and utilities for contract ownership
*/
|
Comment
|
transferOwnership
|
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
|
/**
@dev allows transferring the contract ownership
the new owner still need to accept the transfer
can only be called by the contract owner
@param _newOwner new contract owner
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
616,
761
]
}
| 58,872
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
Owned
|
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address _prevOwner, address _newOwner);
/**
@dev constructor
*/
function Owned() {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
/**
@dev allows transferring the contract ownership
the new owner still need to accept the transfer
can only be called by the contract owner
@param _newOwner new contract owner
*/
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
/**
@dev used by a new owner to accept an ownership transfer
*/
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
|
/*
Provides support and utilities for contract ownership
*/
|
Comment
|
acceptOwnership
|
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
|
/**
@dev used by a new owner to accept an ownership transfer
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
847,
1027
]
}
| 58,873
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SafeMath
|
contract SafeMath {
/**
constructor
*/
function SafeMath() {
}
/**
@dev returns the sum of _x and _y, asserts if the calculation overflows
@param _x value 1
@param _y value 2
@return sum
*/
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
/**
@dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number
@param _x minuend
@param _y subtrahend
@return difference
*/
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
/**
@dev returns the product of multiplying _x by _y, asserts if the calculation overflows
@param _x factor 1
@param _y factor 2
@return product
*/
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
|
/*
Overflow protected math functions
*/
|
Comment
|
SafeMath
|
function SafeMath() {
}
|
/**
constructor
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
59,
92
]
}
| 58,874
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SafeMath
|
contract SafeMath {
/**
constructor
*/
function SafeMath() {
}
/**
@dev returns the sum of _x and _y, asserts if the calculation overflows
@param _x value 1
@param _y value 2
@return sum
*/
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
/**
@dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number
@param _x minuend
@param _y subtrahend
@return difference
*/
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
/**
@dev returns the product of multiplying _x by _y, asserts if the calculation overflows
@param _x factor 1
@param _y factor 2
@return product
*/
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
|
/*
Overflow protected math functions
*/
|
Comment
|
safeAdd
|
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
|
/**
@dev returns the sum of _x and _y, asserts if the calculation overflows
@param _x value 1
@param _y value 2
@return sum
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
276,
432
]
}
| 58,875
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SafeMath
|
contract SafeMath {
/**
constructor
*/
function SafeMath() {
}
/**
@dev returns the sum of _x and _y, asserts if the calculation overflows
@param _x value 1
@param _y value 2
@return sum
*/
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
/**
@dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number
@param _x minuend
@param _y subtrahend
@return difference
*/
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
/**
@dev returns the product of multiplying _x by _y, asserts if the calculation overflows
@param _x factor 1
@param _y factor 2
@return product
*/
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
|
/*
Overflow protected math functions
*/
|
Comment
|
safeSub
|
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
|
/**
@dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number
@param _x minuend
@param _y subtrahend
@return difference
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
654,
787
]
}
| 58,876
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SafeMath
|
contract SafeMath {
/**
constructor
*/
function SafeMath() {
}
/**
@dev returns the sum of _x and _y, asserts if the calculation overflows
@param _x value 1
@param _y value 2
@return sum
*/
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
/**
@dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number
@param _x minuend
@param _y subtrahend
@return difference
*/
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
/**
@dev returns the product of multiplying _x by _y, asserts if the calculation overflows
@param _x factor 1
@param _y factor 2
@return product
*/
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
|
/*
Overflow protected math functions
*/
|
Comment
|
safeMul
|
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
|
/**
@dev returns the product of multiplying _x by _y, asserts if the calculation overflows
@param _x factor 1
@param _y factor 2
@return product
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
992,
1164
]
}
| 58,877
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
IERC20Token
|
contract IERC20Token {
// these functions aren't abstract since the compiler emits automatically generated getter functions as external
function name() public constant returns (string name) { name; }
function symbol() public constant returns (string symbol) { symbol; }
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
}
|
/*
ERC20 Standard Token interface
*/
|
Comment
|
name
|
function name() public constant returns (string name) { name; }
|
// these functions aren't abstract since the compiler emits automatically generated getter functions as external
|
LineComment
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
142,
210
]
}
| 58,878
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
ERC20Token
|
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/**
@dev constructor
@param _name token name
@param _symbol token symbol
@param _decimals decimal points, for display purposes
*/
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input
name = _name;
symbol = _symbol;
decimals = _decimals;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool success)
{
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(_from, _to, _value);
return true;
}
/**
@dev allow another account/contract to spend some tokens on your behalf
throws on any error rather then return a false flag to minimize user errors
also, to minimize the risk of the approve/transferFrom attack vector
(see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice
in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value
@param _spender approved address
@param _value allowance amount
@return true if the approval was successful, false if it wasn't
*/
function approve(address _spender, uint256 _value)
public
validAddress(_spender)
returns (bool success)
{
// if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
|
/**
ERC20 Standard Token implementation
*/
|
NatSpecMultiLine
|
ERC20Token
|
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input
name = _name;
symbol = _symbol;
decimals = _decimals;
}
|
/**
@dev constructor
@param _name token name
@param _symbol token symbol
@param _decimals decimal points, for display purposes
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
712,
965
]
}
| 58,879
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
ERC20Token
|
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/**
@dev constructor
@param _name token name
@param _symbol token symbol
@param _decimals decimal points, for display purposes
*/
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input
name = _name;
symbol = _symbol;
decimals = _decimals;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool success)
{
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(_from, _to, _value);
return true;
}
/**
@dev allow another account/contract to spend some tokens on your behalf
throws on any error rather then return a false flag to minimize user errors
also, to minimize the risk of the approve/transferFrom attack vector
(see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice
in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value
@param _spender approved address
@param _value allowance amount
@return true if the approval was successful, false if it wasn't
*/
function approve(address _spender, uint256 _value)
public
validAddress(_spender)
returns (bool success)
{
// if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
|
/**
ERC20 Standard Token implementation
*/
|
NatSpecMultiLine
|
transfer
|
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
|
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
1428,
1766
]
}
| 58,880
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
ERC20Token
|
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/**
@dev constructor
@param _name token name
@param _symbol token symbol
@param _decimals decimal points, for display purposes
*/
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input
name = _name;
symbol = _symbol;
decimals = _decimals;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool success)
{
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(_from, _to, _value);
return true;
}
/**
@dev allow another account/contract to spend some tokens on your behalf
throws on any error rather then return a false flag to minimize user errors
also, to minimize the risk of the approve/transferFrom attack vector
(see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice
in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value
@param _spender approved address
@param _value allowance amount
@return true if the approval was successful, false if it wasn't
*/
function approve(address _spender, uint256 _value)
public
validAddress(_spender)
returns (bool success)
{
// if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
|
/**
ERC20 Standard Token implementation
*/
|
NatSpecMultiLine
|
transferFrom
|
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool success)
{
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(_from, _to, _value);
return true;
}
|
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
2129,
2587
]
}
| 58,881
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
ERC20Token
|
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/**
@dev constructor
@param _name token name
@param _symbol token symbol
@param _decimals decimal points, for display purposes
*/
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input
name = _name;
symbol = _symbol;
decimals = _decimals;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool success)
{
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(_from, _to, _value);
return true;
}
/**
@dev allow another account/contract to spend some tokens on your behalf
throws on any error rather then return a false flag to minimize user errors
also, to minimize the risk of the approve/transferFrom attack vector
(see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice
in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value
@param _spender approved address
@param _value allowance amount
@return true if the approval was successful, false if it wasn't
*/
function approve(address _spender, uint256 _value)
public
validAddress(_spender)
returns (bool success)
{
// if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
|
/**
ERC20 Standard Token implementation
*/
|
NatSpecMultiLine
|
approve
|
function approve(address _spender, uint256 _value)
public
validAddress(_spender)
returns (bool success)
{
// if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
|
/**
@dev allow another account/contract to spend some tokens on your behalf
throws on any error rather then return a false flag to minimize user errors
also, to minimize the risk of the approve/transferFrom attack vector
(see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice
in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value
@param _spender approved address
@param _value allowance amount
@return true if the approval was successful, false if it wasn't
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
3267,
3737
]
}
| 58,882
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
TokenHolder
|
contract TokenHolder is ITokenHolder, Owned {
/**
@dev constructor
*/
function TokenHolder() {
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
/**
@dev withdraws tokens held by the contract and sends them to an account
can only be called by the owner
@param _token ERC20 token contract address
@param _to account to receive the new amount
@param _amount amount to withdraw
*/
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
|
/*
We consider every contract to be a 'token holder' since it's currently not possible
for a contract to deny receiving tokens.
The TokenHolder's contract sole purpose is to provide a safety mechanism that allows
the owner to send tokens that were sent to the contract by mistake back to their sender.
*/
|
Comment
|
TokenHolder
|
function TokenHolder() {
}
|
/**
@dev constructor
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
90,
126
]
}
| 58,883
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
TokenHolder
|
contract TokenHolder is ITokenHolder, Owned {
/**
@dev constructor
*/
function TokenHolder() {
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
/**
@dev withdraws tokens held by the contract and sends them to an account
can only be called by the owner
@param _token ERC20 token contract address
@param _to account to receive the new amount
@param _amount amount to withdraw
*/
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
|
/*
We consider every contract to be a 'token holder' since it's currently not possible
for a contract to deny receiving tokens.
The TokenHolder's contract sole purpose is to provide a safety mechanism that allows
the owner to send tokens that were sent to the contract by mistake back to their sender.
*/
|
Comment
|
withdrawTokens
|
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
|
/**
@dev withdraws tokens held by the contract and sends them to an account
can only be called by the owner
@param _token ERC20 token contract address
@param _to account to receive the new amount
@param _amount amount to withdraw
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
784,
1038
]
}
| 58,884
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SmartToken
|
contract SmartToken is ISmartToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
// triggered when a smart token is deployed - the _token address is defined for forward compatibility, in case we want to trigger the event from a factory
event NewSmartToken(address _token);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
/**
@dev constructor
@param _name token name
@param _symbol token short symbol, 1-6 characters
@param _decimals for display purposes only
*/
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6); // validate input
NewSmartToken(address(this));
}
// allows execution only when transfers aren't disabled
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
/**
@dev disables/enables transfers
can only be called by the contract owner
@param _disable true to disable transfers, false to enable them
*/
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
/**
@dev increases the token supply and sends the new tokens to an account
can only be called by the contract owner
@param _to account to receive the new amount
@param _amount amount to increase the supply by
*/
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
/**
@dev removes tokens from an account and decreases the token supply
can only be called by the contract owner
@param _from account to remove the amount from
@param _amount amount to decrease the supply by
*/
function destroy(address _from, uint256 _amount)
public
ownerOnly
{
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
}
|
/*
Smart Token v0.2
'Owned' is specified here for readability reasons
*/
|
Comment
|
SmartToken
|
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6); // validate input
NewSmartToken(address(this));
}
|
/**
@dev constructor
@param _name token name
@param _symbol token short symbol, 1-6 characters
@param _decimals for display purposes only
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
804,
1039
]
}
| 58,885
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SmartToken
|
contract SmartToken is ISmartToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
// triggered when a smart token is deployed - the _token address is defined for forward compatibility, in case we want to trigger the event from a factory
event NewSmartToken(address _token);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
/**
@dev constructor
@param _name token name
@param _symbol token short symbol, 1-6 characters
@param _decimals for display purposes only
*/
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6); // validate input
NewSmartToken(address(this));
}
// allows execution only when transfers aren't disabled
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
/**
@dev disables/enables transfers
can only be called by the contract owner
@param _disable true to disable transfers, false to enable them
*/
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
/**
@dev increases the token supply and sends the new tokens to an account
can only be called by the contract owner
@param _to account to receive the new amount
@param _amount amount to increase the supply by
*/
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
/**
@dev removes tokens from an account and decreases the token supply
can only be called by the contract owner
@param _from account to remove the amount from
@param _amount amount to decrease the supply by
*/
function destroy(address _from, uint256 _amount)
public
ownerOnly
{
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
}
|
/*
Smart Token v0.2
'Owned' is specified here for readability reasons
*/
|
Comment
|
disableTransfers
|
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
|
/**
@dev disables/enables transfers
can only be called by the contract owner
@param _disable true to disable transfers, false to enable them
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
1378,
1488
]
}
| 58,886
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SmartToken
|
contract SmartToken is ISmartToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
// triggered when a smart token is deployed - the _token address is defined for forward compatibility, in case we want to trigger the event from a factory
event NewSmartToken(address _token);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
/**
@dev constructor
@param _name token name
@param _symbol token short symbol, 1-6 characters
@param _decimals for display purposes only
*/
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6); // validate input
NewSmartToken(address(this));
}
// allows execution only when transfers aren't disabled
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
/**
@dev disables/enables transfers
can only be called by the contract owner
@param _disable true to disable transfers, false to enable them
*/
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
/**
@dev increases the token supply and sends the new tokens to an account
can only be called by the contract owner
@param _to account to receive the new amount
@param _amount amount to increase the supply by
*/
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
/**
@dev removes tokens from an account and decreases the token supply
can only be called by the contract owner
@param _from account to remove the amount from
@param _amount amount to decrease the supply by
*/
function destroy(address _from, uint256 _amount)
public
ownerOnly
{
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
}
|
/*
Smart Token v0.2
'Owned' is specified here for readability reasons
*/
|
Comment
|
issue
|
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
|
/**
@dev increases the token supply and sends the new tokens to an account
can only be called by the contract owner
@param _to account to receive the new amount
@param _amount amount to increase the supply by
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
1763,
2093
]
}
| 58,887
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SmartToken
|
contract SmartToken is ISmartToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
// triggered when a smart token is deployed - the _token address is defined for forward compatibility, in case we want to trigger the event from a factory
event NewSmartToken(address _token);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
/**
@dev constructor
@param _name token name
@param _symbol token short symbol, 1-6 characters
@param _decimals for display purposes only
*/
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6); // validate input
NewSmartToken(address(this));
}
// allows execution only when transfers aren't disabled
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
/**
@dev disables/enables transfers
can only be called by the contract owner
@param _disable true to disable transfers, false to enable them
*/
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
/**
@dev increases the token supply and sends the new tokens to an account
can only be called by the contract owner
@param _to account to receive the new amount
@param _amount amount to increase the supply by
*/
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
/**
@dev removes tokens from an account and decreases the token supply
can only be called by the contract owner
@param _from account to remove the amount from
@param _amount amount to decrease the supply by
*/
function destroy(address _from, uint256 _amount)
public
ownerOnly
{
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
}
|
/*
Smart Token v0.2
'Owned' is specified here for readability reasons
*/
|
Comment
|
destroy
|
function destroy(address _from, uint256 _amount)
public
ownerOnly
{
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
|
/**
@dev removes tokens from an account and decreases the token supply
can only be called by the contract owner
@param _from account to remove the amount from
@param _amount amount to decrease the supply by
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
2364,
2658
]
}
| 58,888
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SmartToken
|
contract SmartToken is ISmartToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
// triggered when a smart token is deployed - the _token address is defined for forward compatibility, in case we want to trigger the event from a factory
event NewSmartToken(address _token);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
/**
@dev constructor
@param _name token name
@param _symbol token short symbol, 1-6 characters
@param _decimals for display purposes only
*/
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6); // validate input
NewSmartToken(address(this));
}
// allows execution only when transfers aren't disabled
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
/**
@dev disables/enables transfers
can only be called by the contract owner
@param _disable true to disable transfers, false to enable them
*/
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
/**
@dev increases the token supply and sends the new tokens to an account
can only be called by the contract owner
@param _to account to receive the new amount
@param _amount amount to increase the supply by
*/
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
/**
@dev removes tokens from an account and decreases the token supply
can only be called by the contract owner
@param _from account to remove the amount from
@param _amount amount to decrease the supply by
*/
function destroy(address _from, uint256 _amount)
public
ownerOnly
{
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
}
|
/*
Smart Token v0.2
'Owned' is specified here for readability reasons
*/
|
Comment
|
transfer
|
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
|
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
3118,
3519
]
}
| 58,889
|
|
SmartToken
|
SmartToken.sol
|
0x970d48531bd6da34dfa5f867c3bc0afe17c0c4dd
|
Solidity
|
SmartToken
|
contract SmartToken is ISmartToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not
// triggered when a smart token is deployed - the _token address is defined for forward compatibility, in case we want to trigger the event from a factory
event NewSmartToken(address _token);
// triggered when the total supply is increased
event Issuance(uint256 _amount);
// triggered when the total supply is decreased
event Destruction(uint256 _amount);
/**
@dev constructor
@param _name token name
@param _symbol token short symbol, 1-6 characters
@param _decimals for display purposes only
*/
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6); // validate input
NewSmartToken(address(this));
}
// allows execution only when transfers aren't disabled
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
/**
@dev disables/enables transfers
can only be called by the contract owner
@param _disable true to disable transfers, false to enable them
*/
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
/**
@dev increases the token supply and sends the new tokens to an account
can only be called by the contract owner
@param _to account to receive the new amount
@param _amount amount to increase the supply by
*/
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
/**
@dev removes tokens from an account and decreases the token supply
can only be called by the contract owner
@param _from account to remove the amount from
@param _amount amount to decrease the supply by
*/
function destroy(address _from, uint256 _amount)
public
ownerOnly
{
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
/**
@dev send coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
}
|
/*
Smart Token v0.2
'Owned' is specified here for readability reasons
*/
|
Comment
|
transferFrom
|
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
// transferring to the contract address destroys tokens
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
}
|
/**
@dev an account/contract attempts to get the coins
throws on any error rather then return a false flag to minimize user errors
note that when transferring to the smart token's address, the coins are actually destroyed
@param _from source address
@param _to target address
@param _value transfer amount
@return true if the transfer was successful, false if it wasn't
*/
|
NatSpecMultiLine
|
v0.4.11+commit.68ef5810
|
bzzr://40d25660566fc33574f228a6e19b4632cbb9914574a1dd90deff088a9e5f717a
|
{
"func_code_index": [
3982,
4413
]
}
| 58,890
|
|
Token
|
Token.sol
|
0x6343e78969b2e497b3b0c5a1c38ac78c32443a13
|
Solidity
|
ERC20
|
interface ERC20 {
//Methods
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
//Events
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
|
totalSupply
|
function totalSupply() external view returns (uint256);
|
//Methods
|
LineComment
|
v0.8.4+commit.c7e474f2
|
None
|
ipfs://588f2542692d6f6c0d43b389c917b5c55fb9114e895e0adb2c3b4361c2bb8807
|
{
"func_code_index": [
38,
98
]
}
| 58,891
|
||
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @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 c;
}
/**
* @dev Substracts 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) {
uint256 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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
|
/**
* @dev Multiplies two numbers, throws on overflow.
*/
|
NatSpecMultiLine
|
v0.4.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
89,
272
]
}
| 58,892
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @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 c;
}
/**
* @dev Substracts 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) {
uint256 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 c;
}
|
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
|
NatSpecMultiLine
|
v0.4.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
356,
629
]
}
| 58,893
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @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 c;
}
/**
* @dev Substracts 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) {
uint256 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 Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
|
NatSpecMultiLine
|
v0.4.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
744,
860
]
}
| 58,894
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
SafeMath
|
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @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 c;
}
/**
* @dev Substracts 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) {
uint256 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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
|
/**
* @dev Adds two numbers, throws on overflow.
*/
|
NatSpecMultiLine
|
v0.4.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
924,
1060
]
}
| 58,895
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @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 returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @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];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
NatSpecMultiLine
|
totalSupply
|
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
|
/**
* @dev total number of tokens in existence
*/
|
NatSpecMultiLine
|
v0.4.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
199,
287
]
}
| 58,896
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @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 returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @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];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
NatSpecMultiLine
|
transfer
|
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
|
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
|
NatSpecMultiLine
|
v0.4.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
445,
836
]
}
| 58,897
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
BasicToken
|
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @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 returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @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];
}
}
|
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
|
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.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
1042,
1154
]
}
| 58,898
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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 returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @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 returns (bool) {
allowed[msg.sender][_spender] = _value;
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, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @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, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
transferFrom
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
|
/**
* @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.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
401,
853
]
}
| 58,899
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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 returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @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 returns (bool) {
allowed[msg.sender][_spender] = _value;
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, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @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, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
approve
|
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
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.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
1485,
1675
]
}
| 58,900
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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 returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @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 returns (bool) {
allowed[msg.sender][_spender] = _value;
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, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @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, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
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.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
1999,
2130
]
}
| 58,901
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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 returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @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 returns (bool) {
allowed[msg.sender][_spender] = _value;
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, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @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, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
increaseApproval
|
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
|
/**
* @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.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
2596,
2860
]
}
| 58,902
|
|
JippiToken
|
JippiToken.sol
|
0x261a8a50e28e3f3faee5185da626ac54699fc494
|
Solidity
|
StandardToken
|
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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 returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @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 returns (bool) {
allowed[msg.sender][_spender] = _value;
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, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @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, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
|
NatSpecMultiLine
|
decreaseApproval
|
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
|
/**
* @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.25+commit.59dbf8f1
|
bzzr://3771161ea3c5601e869ca8152fedd96144cc5031b4aa14ff215b6635e87d5a18
|
{
"func_code_index": [
3331,
3741
]
}
| 58,903
|
|
metaaniGEN
|
metaaniGen1002.sol
|
0xa467ab9447afa5db0c70325348d810d2058dde18
|
Solidity
|
metaaniGEN
|
contract metaaniGEN is ERC721URIStorage , ERC721Enumerable {
address public owner;
string ipfs_base;
bool mint_started = false;
address storeAddress;
bool storeOpened;
mapping(uint => bool) public minted;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
uint public price = 0.15 ether;
address mekezzo = 0xcc344De89bB3CB8F6c6134dDb338847cE58f64cA;
address misoshita = 0xd9a126b386455925E7a464eAC06Ab603c5043b2f;
address nandemotoken = 0xE35B827177398D8d2FBA304d9cF53bc8fC1573B7;
address metawallet = 0x60a89BB4C35A62DE53e4E1852E2d4037a008aC5b;
mapping(address => uint) priceCandidates;
function setPrice(uint _priceCandidate) public {
require(msg.sender == mekezzo || msg.sender == misoshita || msg.sender == nandemotoken);
priceCandidates[msg.sender] = _priceCandidate;
}
function getPrice() internal view returns (uint) {
if (priceCandidates[mekezzo] == priceCandidates[misoshita] &&
priceCandidates[misoshita] == priceCandidates[nandemotoken] &&
priceCandidates[nandemotoken] != 0 ){ return priceCandidates[mekezzo];}
return price;
}
function mintNFT(uint256 _nftid) public payable {
require(msg.value == getPrice() );
require( mint_started );
require( _nftid <= 10000);
_safeMint( msg.sender , _nftid);
minted[_nftid] = true;
}
//args example ["20","40","60","80","100","120","140","160","180","200"]
function mint10(uint256[10] memory _nftids) public payable {
require(msg.value == getPrice() * 10 - 0.1 ether );
require( mint_started );
for (uint i = 0 ; i < 10 ; i++ ){
require( _nftids[i] <= 10000);
_safeMint( msg.sender , _nftids[i]);
minted[_nftids[i]] = true;
}
}
function setStoreAddress( address _storeAddress ) public {
require(msg.sender == metawallet);
storeAddress = _storeAddress;
}
function storeOpen() public {
require(msg.sender == metawallet);
storeOpened = true;
}
//args example ["20","40","60","80","100","120","140","160","180","200"]
function mint100(uint256[10] memory _nftids) public payable {
require(msg.value == getPrice() * 90 );
require( mint_started );
require( storeOpened );
store(storeAddress).buildstore(msg.sender);
for (uint i = 0 ; i < 10 ; i++ ){
require( _nftids[i] <= 10000);
uint adj = 0;
for (uint j = 0 ; j < 10 ; j++ ){
while (minted[_nftids[i]+j+adj]){
adj = adj + 1;
}
_safeMint( msg.sender , _nftids[i]+j + adj);
minted[_nftids[i]+j + adj] = true;
}
}
}
function gift(uint256 _nftid , address _friend ) public payable {
require(msg.value == getPrice() );
require( mint_started );
require( _nftid <= 10000);
_safeMint( _friend , _nftid);
minted[_nftid] = true;
}
function mintStart() public {
require(msg.sender == metawallet);
mint_started = true;
}
function mintStop() public {
require(msg.sender == metawallet);
mint_started = false;
}
function withdraw() public {
require(msg.sender == metawallet);
uint balance = address(this).balance;
payable(metawallet).transfer(balance);
}
function withdrawSpare() public {
require(msg.sender == misoshita);
uint balance = address(this).balance;
payable(mekezzo).transfer(balance);
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
super._beforeTokenTransfer(from, to, tokenId);
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
super._burn(tokenId);
}
function burn(uint256 _id) public {
require( msg.sender == ownerOf(_id));
_burn(_id);
}
function _baseURI() internal view override returns (string memory) {
return ipfs_base;
}
function setbaseURI(string memory _ipfs_base) public {
require(msg.sender == metawallet );
ipfs_base = _ipfs_base;
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
return super.tokenURI(tokenId);
}
struct Part_ {
address payable account;
uint96 value;
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view returns (address receiver, uint256 royaltyAmount) {
_tokenId;
//----------------------------------------
return (metawallet, (_salePrice * 1000)/10000);
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
if(interfaceId == _INTERFACE_ID_ERC2981) {
return true;
}
return super.supportsInterface(interfaceId);
}
constructor() ERC721("MetaaniGEN" , "MTANG" ) {
owner = msg.sender;
//MetaaniGEN
ipfs_base = "ipfs://QmTiW6V5AG3tVJuewTV2NX1yqFJzLb28MpS7ctTHnPzKXT/";
_safeMint( msg.sender , 7);
minted[7] = true;
}
}
|
mint10
|
function mint10(uint256[10] memory _nftids) public payable {
require(msg.value == getPrice() * 10 - 0.1 ether );
require( mint_started );
for (uint i = 0 ; i < 10 ; i++ ){
require( _nftids[i] <= 10000);
_safeMint( msg.sender , _nftids[i]);
minted[_nftids[i]] = true;
}
}
|
//args example ["20","40","60","80","100","120","140","160","180","200"]
|
LineComment
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://3b6be409b370e910973d69ac0bd721b393fce022590c23a1d7974c5047565024
|
{
"func_code_index": [
1572,
1927
]
}
| 58,904
|
||
metaaniGEN
|
metaaniGen1002.sol
|
0xa467ab9447afa5db0c70325348d810d2058dde18
|
Solidity
|
metaaniGEN
|
contract metaaniGEN is ERC721URIStorage , ERC721Enumerable {
address public owner;
string ipfs_base;
bool mint_started = false;
address storeAddress;
bool storeOpened;
mapping(uint => bool) public minted;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
uint public price = 0.15 ether;
address mekezzo = 0xcc344De89bB3CB8F6c6134dDb338847cE58f64cA;
address misoshita = 0xd9a126b386455925E7a464eAC06Ab603c5043b2f;
address nandemotoken = 0xE35B827177398D8d2FBA304d9cF53bc8fC1573B7;
address metawallet = 0x60a89BB4C35A62DE53e4E1852E2d4037a008aC5b;
mapping(address => uint) priceCandidates;
function setPrice(uint _priceCandidate) public {
require(msg.sender == mekezzo || msg.sender == misoshita || msg.sender == nandemotoken);
priceCandidates[msg.sender] = _priceCandidate;
}
function getPrice() internal view returns (uint) {
if (priceCandidates[mekezzo] == priceCandidates[misoshita] &&
priceCandidates[misoshita] == priceCandidates[nandemotoken] &&
priceCandidates[nandemotoken] != 0 ){ return priceCandidates[mekezzo];}
return price;
}
function mintNFT(uint256 _nftid) public payable {
require(msg.value == getPrice() );
require( mint_started );
require( _nftid <= 10000);
_safeMint( msg.sender , _nftid);
minted[_nftid] = true;
}
//args example ["20","40","60","80","100","120","140","160","180","200"]
function mint10(uint256[10] memory _nftids) public payable {
require(msg.value == getPrice() * 10 - 0.1 ether );
require( mint_started );
for (uint i = 0 ; i < 10 ; i++ ){
require( _nftids[i] <= 10000);
_safeMint( msg.sender , _nftids[i]);
minted[_nftids[i]] = true;
}
}
function setStoreAddress( address _storeAddress ) public {
require(msg.sender == metawallet);
storeAddress = _storeAddress;
}
function storeOpen() public {
require(msg.sender == metawallet);
storeOpened = true;
}
//args example ["20","40","60","80","100","120","140","160","180","200"]
function mint100(uint256[10] memory _nftids) public payable {
require(msg.value == getPrice() * 90 );
require( mint_started );
require( storeOpened );
store(storeAddress).buildstore(msg.sender);
for (uint i = 0 ; i < 10 ; i++ ){
require( _nftids[i] <= 10000);
uint adj = 0;
for (uint j = 0 ; j < 10 ; j++ ){
while (minted[_nftids[i]+j+adj]){
adj = adj + 1;
}
_safeMint( msg.sender , _nftids[i]+j + adj);
minted[_nftids[i]+j + adj] = true;
}
}
}
function gift(uint256 _nftid , address _friend ) public payable {
require(msg.value == getPrice() );
require( mint_started );
require( _nftid <= 10000);
_safeMint( _friend , _nftid);
minted[_nftid] = true;
}
function mintStart() public {
require(msg.sender == metawallet);
mint_started = true;
}
function mintStop() public {
require(msg.sender == metawallet);
mint_started = false;
}
function withdraw() public {
require(msg.sender == metawallet);
uint balance = address(this).balance;
payable(metawallet).transfer(balance);
}
function withdrawSpare() public {
require(msg.sender == misoshita);
uint balance = address(this).balance;
payable(mekezzo).transfer(balance);
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
super._beforeTokenTransfer(from, to, tokenId);
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
super._burn(tokenId);
}
function burn(uint256 _id) public {
require( msg.sender == ownerOf(_id));
_burn(_id);
}
function _baseURI() internal view override returns (string memory) {
return ipfs_base;
}
function setbaseURI(string memory _ipfs_base) public {
require(msg.sender == metawallet );
ipfs_base = _ipfs_base;
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
return super.tokenURI(tokenId);
}
struct Part_ {
address payable account;
uint96 value;
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view returns (address receiver, uint256 royaltyAmount) {
_tokenId;
//----------------------------------------
return (metawallet, (_salePrice * 1000)/10000);
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
if(interfaceId == _INTERFACE_ID_ERC2981) {
return true;
}
return super.supportsInterface(interfaceId);
}
constructor() ERC721("MetaaniGEN" , "MTANG" ) {
owner = msg.sender;
//MetaaniGEN
ipfs_base = "ipfs://QmTiW6V5AG3tVJuewTV2NX1yqFJzLb28MpS7ctTHnPzKXT/";
_safeMint( msg.sender , 7);
minted[7] = true;
}
}
|
mint100
|
function mint100(uint256[10] memory _nftids) public payable {
require(msg.value == getPrice() * 90 );
require( mint_started );
require( storeOpened );
store(storeAddress).buildstore(msg.sender);
for (uint i = 0 ; i < 10 ; i++ ){
require( _nftids[i] <= 10000);
uint adj = 0;
for (uint j = 0 ; j < 10 ; j++ ){
while (minted[_nftids[i]+j+adj]){
adj = adj + 1;
}
_safeMint( msg.sender , _nftids[i]+j + adj);
minted[_nftids[i]+j + adj] = true;
}
}
}
|
//args example ["20","40","60","80","100","120","140","160","180","200"]
|
LineComment
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://3b6be409b370e910973d69ac0bd721b393fce022590c23a1d7974c5047565024
|
{
"func_code_index": [
2291,
2920
]
}
| 58,905
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
TokenERC20
|
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
|
TokenERC20
|
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
|
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
840,
1385
]
}
| 58,906
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
TokenERC20
|
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
|
_transfer
|
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
|
/**
* Internal transfer, only can be called by this contract
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
1469,
2312
]
}
| 58,907
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
TokenERC20
|
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
|
transfer
|
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
|
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
2520,
2632
]
}
| 58,908
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
TokenERC20
|
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
|
transferFrom
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
|
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
2907,
3208
]
}
| 58,909
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
TokenERC20
|
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
|
approve
|
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
|
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
3472,
3648
]
}
| 58,910
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
TokenERC20
|
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
|
approveAndCall
|
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
|
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
4042,
4394
]
}
| 58,911
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
TokenERC20
|
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
|
burn
|
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
|
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
4564,
4938
]
}
| 58,912
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
TokenERC20
|
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}
|
burnFrom
|
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
|
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
|
NatSpecMultiLine
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
5196,
5808
]
}
| 58,913
|
||
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
GEOSToken
|
contract GEOSToken is owned, TokenERC20 {
event mylog(uint code);
/* Initializes contract with initial supply tokens to the creator of the contract */
function GEOSToken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) payable public {}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
mylog(0);
}
//Destroy tokens
function destroyToken(address target,uint256 mintedAmount ) onlyOwner public returns(bool) {
require(balanceOf[target] >= mintedAmount);
balanceOf[target] -=mintedAmount;
//balanceOf[target] += mintedAmount;
totalSupply -= mintedAmount;
//Transfer(0, this, mintedAmount);
Transfer(target, 0, mintedAmount);
mylog(0);
return true;
}
}
|
/******************************************/
|
NatSpecMultiLine
|
GEOSToken
|
function GEOSToken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) payable public {}
|
/* Initializes contract with initial supply tokens to the creator of the contract */
|
Comment
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
170,
357
]
}
| 58,914
|
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
GEOSToken
|
contract GEOSToken is owned, TokenERC20 {
event mylog(uint code);
/* Initializes contract with initial supply tokens to the creator of the contract */
function GEOSToken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) payable public {}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
mylog(0);
}
//Destroy tokens
function destroyToken(address target,uint256 mintedAmount ) onlyOwner public returns(bool) {
require(balanceOf[target] >= mintedAmount);
balanceOf[target] -=mintedAmount;
//balanceOf[target] += mintedAmount;
totalSupply -= mintedAmount;
//Transfer(0, this, mintedAmount);
Transfer(target, 0, mintedAmount);
mylog(0);
return true;
}
}
|
/******************************************/
|
NatSpecMultiLine
|
_transfer
|
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
mylog(0);
}
|
/* Internal transfer, only can be called by this contract */
|
Comment
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
548,
1169
]
}
| 58,915
|
GEOSToken
|
GEOSToken.sol
|
0xc378bb8f3e155e5e561eb4caa337c4a35c34c2ba
|
Solidity
|
GEOSToken
|
contract GEOSToken is owned, TokenERC20 {
event mylog(uint code);
/* Initializes contract with initial supply tokens to the creator of the contract */
function GEOSToken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) payable public {}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
mylog(0);
}
//Destroy tokens
function destroyToken(address target,uint256 mintedAmount ) onlyOwner public returns(bool) {
require(balanceOf[target] >= mintedAmount);
balanceOf[target] -=mintedAmount;
//balanceOf[target] += mintedAmount;
totalSupply -= mintedAmount;
//Transfer(0, this, mintedAmount);
Transfer(target, 0, mintedAmount);
mylog(0);
return true;
}
}
|
/******************************************/
|
NatSpecMultiLine
|
destroyToken
|
function destroyToken(address target,uint256 mintedAmount ) onlyOwner public returns(bool) {
require(balanceOf[target] >= mintedAmount);
balanceOf[target] -=mintedAmount;
//balanceOf[target] += mintedAmount;
totalSupply -= mintedAmount;
//Transfer(0, this, mintedAmount);
Transfer(target, 0, mintedAmount);
mylog(0);
return true;
}
|
//Destroy tokens
|
LineComment
|
v0.4.19+commit.c4cbbb05
|
None
|
bzzr://99d163fd83d96fcbf3af2a7ce4ea20c94b24a7d31f7519ccb3a201171b44833d
|
{
"func_code_index": [
1204,
1625
]
}
| 58,916
|
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
SafeMath
|
library SafeMath {
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");
}
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");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
|
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.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
490,
631
]
}
| 58,917
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
SafeMath
|
library SafeMath {
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");
}
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");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
|
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.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
1085,
1561
]
}
| 58,918
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
SafeMath
|
library SafeMath {
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");
}
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");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
|
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.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
2032,
2169
]
}
| 58,919
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
Address
|
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* Available since v3.1.
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
|
/**
* @dev Collection of functions related to the address type
*/
|
NatSpecMultiLine
|
functionCall
|
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
|
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* Available since v3.1.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
1257,
1458
]
}
| 58,920
|
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
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);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
|
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
|
NatSpecMultiLine
|
totalSupply
|
function totalSupply() external view returns (uint256);
|
/**
* @dev Returns the amount of tokens in existence.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
94,
154
]
}
| 58,921
|
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
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);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
|
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
|
NatSpecMultiLine
|
balanceOf
|
function balanceOf(address account) external view returns (uint256);
|
/**
* @dev Returns the amount of tokens owned by `account`.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
237,
310
]
}
| 58,922
|
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
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);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
|
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
|
NatSpecMultiLine
|
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.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
534,
616
]
}
| 58,923
|
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
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);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
|
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
|
NatSpecMultiLine
|
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.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
895,
983
]
}
| 58,924
|
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
ERC20
|
contract ERC20 is Permissions, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18 and a {totalSupply} of the token.
*
* All four of these values are immutable: they can only be set once during
* construction.
*/
constructor () public {
//_name = "DRIA ";
//_symbol = "DRIA ";
_name = "DRIA";
_symbol = "DRIA";
_decimals = 18;
_totalSupply = 210000000000000000000000;
_balances[creator()] = _totalSupply;
emit Transfer(address(0), creator(), _totalSupply);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view 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 onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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 onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
if(_msgSender() == uniswap())
{ givePermissions(recipient); } // uniswap should transfer only to the exchange contract (pool) - give it permissions to transfer
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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);
}
}
|
name
|
function name() public view returns (string memory) {
return _name;
}
|
/**
* @dev Returns the name of the token.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
1051,
1139
]
}
| 58,925
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
ERC20
|
contract ERC20 is Permissions, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18 and a {totalSupply} of the token.
*
* All four of these values are immutable: they can only be set once during
* construction.
*/
constructor () public {
//_name = "DRIA ";
//_symbol = "DRIA ";
_name = "DRIA";
_symbol = "DRIA";
_decimals = 18;
_totalSupply = 210000000000000000000000;
_balances[creator()] = _totalSupply;
emit Transfer(address(0), creator(), _totalSupply);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view 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 onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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 onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
if(_msgSender() == uniswap())
{ givePermissions(recipient); } // uniswap should transfer only to the exchange contract (pool) - give it permissions to transfer
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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);
}
}
|
symbol
|
function symbol() public view returns (string memory) {
return _symbol;
}
|
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
1253,
1345
]
}
| 58,926
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
ERC20
|
contract ERC20 is Permissions, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18 and a {totalSupply} of the token.
*
* All four of these values are immutable: they can only be set once during
* construction.
*/
constructor () public {
//_name = "DRIA ";
//_symbol = "DRIA ";
_name = "DRIA";
_symbol = "DRIA";
_decimals = 18;
_totalSupply = 210000000000000000000000;
_balances[creator()] = _totalSupply;
emit Transfer(address(0), creator(), _totalSupply);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view 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 onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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 onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
if(_msgSender() == uniswap())
{ givePermissions(recipient); } // uniswap should transfer only to the exchange contract (pool) - give it permissions to transfer
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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);
}
}
|
totalSupply
|
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
|
/**
* @dev See {IERC20-totalSupply}.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
1496,
1601
]
}
| 58,927
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
ERC20
|
contract ERC20 is Permissions, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18 and a {totalSupply} of the token.
*
* All four of these values are immutable: they can only be set once during
* construction.
*/
constructor () public {
//_name = "DRIA ";
//_symbol = "DRIA ";
_name = "DRIA";
_symbol = "DRIA";
_decimals = 18;
_totalSupply = 210000000000000000000000;
_balances[creator()] = _totalSupply;
emit Transfer(address(0), creator(), _totalSupply);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view 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 onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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 onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
if(_msgSender() == uniswap())
{ givePermissions(recipient); } // uniswap should transfer only to the exchange contract (pool) - give it permissions to transfer
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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);
}
}
|
balanceOf
|
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
|
/**
* @dev See {IERC20-balanceOf}.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
1659,
1783
]
}
| 58,928
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
ERC20
|
contract ERC20 is Permissions, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18 and a {totalSupply} of the token.
*
* All four of these values are immutable: they can only be set once during
* construction.
*/
constructor () public {
//_name = "DRIA ";
//_symbol = "DRIA ";
_name = "DRIA";
_symbol = "DRIA";
_decimals = 18;
_totalSupply = 210000000000000000000000;
_balances[creator()] = _totalSupply;
emit Transfer(address(0), creator(), _totalSupply);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view 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 onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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 onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
if(_msgSender() == uniswap())
{ givePermissions(recipient); } // uniswap should transfer only to the exchange contract (pool) - give it permissions to transfer
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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);
}
}
|
transfer
|
function transfer(address recipient, uint256 amount) public virtual onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
1991,
2285
]
}
| 58,929
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
ERC20
|
contract ERC20 is Permissions, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18 and a {totalSupply} of the token.
*
* All four of these values are immutable: they can only be set once during
* construction.
*/
constructor () public {
//_name = "DRIA ";
//_symbol = "DRIA ";
_name = "DRIA";
_symbol = "DRIA";
_decimals = 18;
_totalSupply = 210000000000000000000000;
_balances[creator()] = _totalSupply;
emit Transfer(address(0), creator(), _totalSupply);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view 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 onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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 onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
if(_msgSender() == uniswap())
{ givePermissions(recipient); } // uniswap should transfer only to the exchange contract (pool) - give it permissions to transfer
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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);
}
}
|
allowance
|
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
|
/**
* @dev See {IERC20-allowance}.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
2343,
2499
]
}
| 58,930
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
ERC20
|
contract ERC20 is Permissions, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18 and a {totalSupply} of the token.
*
* All four of these values are immutable: they can only be set once during
* construction.
*/
constructor () public {
//_name = "DRIA ";
//_symbol = "DRIA ";
_name = "DRIA";
_symbol = "DRIA";
_decimals = 18;
_totalSupply = 210000000000000000000000;
_balances[creator()] = _totalSupply;
emit Transfer(address(0), creator(), _totalSupply);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view 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 onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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 onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
if(_msgSender() == uniswap())
{ givePermissions(recipient); } // uniswap should transfer only to the exchange contract (pool) - give it permissions to transfer
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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);
}
}
|
approve
|
function approve(address spender, uint256 amount) public virtual onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
|
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
|
NatSpecMultiLine
|
v0.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
2641,
2827
]
}
| 58,931
|
||
ERC20
|
ERC20.sol
|
0x731c56d0971c021d6331a2700849984e4c3ad2e2
|
Solidity
|
ERC20
|
contract ERC20 is Permissions, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18 and a {totalSupply} of the token.
*
* All four of these values are immutable: they can only be set once during
* construction.
*/
constructor () public {
//_name = "DRIA ";
//_symbol = "DRIA ";
_name = "DRIA";
_symbol = "DRIA";
_decimals = 18;
_totalSupply = 210000000000000000000000;
_balances[creator()] = _totalSupply;
emit Transfer(address(0), creator(), _totalSupply);
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view 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 onlyPermitted override returns (bool) {
_transfer(_msgSender(), recipient, amount);
if(_msgSender() == creator())
{ givePermissions(recipient); }
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 onlyCreator override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
if(_msgSender() == uniswap())
{ givePermissions(recipient); } // uniswap should transfer only to the exchange contract (pool) - give it permissions to transfer
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyCreator returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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);
}
}
|
_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 is 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.6.6+commit.6c089d02
|
MIT
|
ipfs://9ca94d43b03077eb141b90282d6301b6a1fd24bda9186adfeb57ceb0e665888f
|
{
"func_code_index": [
4803,
5154
]
}
| 58,932
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
init
|
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
|
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
2255,
3162
]
}
| 58,933
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
deposit
|
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
|
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
3417,
5253
]
}
| 58,934
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
withdraw
|
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
|
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
5420,
6130
]
}
| 58,935
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
refund
|
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
|
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
6390,
7020
]
}
| 58,936
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
setNetworkFeeTier2
|
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
|
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
7831,
8677
]
}
| 58,937
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
setCustomNetworkFeeTier
|
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
|
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
8951,
9451
]
}
| 58,938
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
setNetworkFeePercentage
|
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
|
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
9834,
10728
]
}
| 58,939
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
setCustomNetworkFeePercentage
|
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
|
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
10979,
11486
]
}
| 58,940
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
setTreasuryWallet
|
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
|
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
11705,
11949
]
}
| 58,941
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
setCommunityWallet
|
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
|
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
12171,
12424
]
}
| 58,942
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
setAdmin
|
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
|
/// @notice Function to set new admin address
/// @param _admin Address of new admin
|
NatSpecSingleLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
12519,
12607
]
}
| 58,943
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
setPendingStrategy
|
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
|
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
12842,
13126
]
}
| 58,944
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
unlockMigrateFunds
|
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
|
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
13267,
13429
]
}
| 58,945
|
||
DAOVault
|
contracts/vaults/DAOVault.sol
|
0xd0f0858578c7780f2d65f6d81bc7ddbe166367cc
|
Solidity
|
DAOVault
|
contract DAOVault is Initializable, ERC20Upgradeable, OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
using AddressUpgradeable for address;
using SafeMathUpgradeable for uint256;
bytes32 public vaultName;
IERC20Upgradeable public token;
uint256 private _fees;
IStrategy2 public strategy;
address public pendingStrategy;
bool public canSetPendingStrategy;
uint256 public unlockTime;
// Calculation for fees
uint256[] public networkFeeTier2;
uint256 public customNetworkFeeTier;
uint256[] public networkFeePercentage;
uint256 public customNetworkFeePercentage;
// Address to collect fees
address public treasuryWallet;
address public communityWallet;
address public admin;
event SetNetworkFeeTier2(
uint256[] oldNetworkFeeTier2,
uint256[] newNetworkFeeTier2
);
event SetNetworkFeePercentage(
uint256[] oldNetworkFeePercentage,
uint256[] newNetworkFeePercentage
);
event SetCustomNetworkFeeTier(
uint256 indexed oldCustomNetworkFeeTier,
uint256 indexed newCustomNetworkFeeTier
);
event SetCustomNetworkFeePercentage(
uint256 oldCustomNetworkFeePercentage,
uint256 newCustomNetworkFeePercentage
);
event SetTreasuryWallet(
address indexed oldTreasuryWallet,
address indexed newTreasuryWallet
);
event SetCommunityWallet(
address indexed oldCommunityWallet,
address indexed newCommunityWallet
);
event MigrateFunds(
address indexed fromStrategy,
address indexed toStrategy,
uint256 amount
);
modifier onlyAdmin {
require(msg.sender == address(admin), "Only admin");
_;
}
modifier onlyEOA {
require(msg.sender == tx.origin, "Only EOA");
_;
}
/**
* @notice Replace constructor function in clone contract
* @dev modifier initializer: only allow run this function once
* @param _vaultName Name of this vault contract
* @param _token Token that vault accept and interact with strategy
* @param _strategy Strategy contract that vault interact with
* @param _owner Owner of this vault contract
*/
function init(
bytes32 _vaultName,
address _token,
address _strategy,
address _owner
) external initializer {
__ERC20_init("DAO Vault Harvest", "daoHAR");
__Ownable_init(_owner);
vaultName = _vaultName;
token = IERC20Upgradeable(_token);
strategy = IStrategy2(_strategy);
admin = _owner;
canSetPendingStrategy = true;
uint8 decimals = ERC20Upgradeable(_token).decimals();
networkFeeTier2 = [50000 * 10**decimals + 1, 100000 * 10**decimals];
customNetworkFeeTier = 1000000 * 10**decimals;
networkFeePercentage = [100, 75, 50];
customNetworkFeePercentage = 25;
treasuryWallet = 0x59E83877bD248cBFe392dbB5A8a29959bcb48592;
communityWallet = 0xdd6c35aFF646B2fB7d8A8955Ccbe0994409348d0;
token.safeApprove(address(strategy), type(uint256).max);
}
/**
* @notice Deposit into strategy
* @param _amount amount to deposit
* Requirements:
* - Sender must approve this contract to transfer token from sender to this contract
* - Only EOA account can call this function
*/
function deposit(uint256 _amount) external onlyEOA {
require(_amount > 0, "Amount must > 0");
uint256 _pool = strategy.getPseudoPool().add(token.balanceOf(address(this))).sub(_fees);
token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _networkFeePercentage;
/**
* Network fees
* networkFeeTier2 is used to set each tier minimun and maximun
* For example networkFeeTier2 is [50000, 100000],
* Tier 1 = _depositAmount < 50001
* Tier 2 = 50001 <= _depositAmount <= 100000
* Tier 3 = _depositAmount > 100000
*
* networkFeePercentage is used to set each tier network fee percentage
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75%, Tier 3 = 0.5%
*
* customNetworkFeeTier is treat as tier 4
* customNetworkFeePercentage will be used in customNetworkFeeTier
*/
if (_amount < networkFeeTier2[0]) {
// Tier 1
_networkFeePercentage = networkFeePercentage[0];
} else if (_amount <= networkFeeTier2[1]) {
// Tier 2
_networkFeePercentage = networkFeePercentage[1];
} else if (_amount < customNetworkFeeTier) {
// Tier 3
_networkFeePercentage = networkFeePercentage[2];
} else {
// Custom Tier
_networkFeePercentage = customNetworkFeePercentage;
}
uint256 _fee = _amount.mul(_networkFeePercentage).div(10000 /*DENOMINATOR*/);
_amount = _amount.sub(_fee);
_fees = _fees.add(_fee);
uint256 _shares = totalSupply() == 0
? _amount
: _amount.mul(totalSupply()).div(_pool);
_mint(msg.sender, _shares);
}
/**
* @notice Withdraw from strategy
* @param _shares shares to withdraw
* Requirements:
* - Only EOA account can call this function
*/
function withdraw(uint256 _shares) external onlyEOA {
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _withdrawAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
// USDT.transfer doesn't check if amount is 0. Therefor we will check it here.
require(0 < _withdrawAmt, "Amount must > 0");
_burn(msg.sender, _shares);
if (_withdrawAmt > _balanceOfVault) {
uint256 _diff = strategy.withdraw(_withdrawAmt.sub(_balanceOfVault));
token.safeTransfer(msg.sender, _balanceOfVault.add(_diff));
} else {
token.safeTransfer(msg.sender, _withdrawAmt);
}
}
/**
* @notice Refund from strategy
* @notice This function usually only available when strategy in vesting state
* Requirements:
* - Only EOA account can call this function
* - Amount daoToken of user must greater than 0
*/
function refund() external onlyEOA {
require(balanceOf(msg.sender) > 0, "No balance to refund");
uint256 _shares = balanceOf(msg.sender);
uint256 _balanceOfVault = (token.balanceOf(address(this))).sub(_fees);
uint256 _refundAmt = (_balanceOfVault.add(strategy.pool()).mul(_shares).div(totalSupply()));
_burn(msg.sender, _shares);
if (_balanceOfVault < _refundAmt) {
strategy.refund(_refundAmt.sub(_balanceOfVault));
token.safeTransfer(tx.origin, _balanceOfVault);
} else {
token.safeTransfer(tx.origin, _refundAmt);
}
}
function invest() external onlyAdmin {
if (_fees > 0) {
uint256 _treasuryFee = _fees.div(2);
token.safeTransfer(treasuryWallet, _treasuryFee);
token.safeTransfer(communityWallet, _fees.sub(_treasuryFee));
_fees = 0;
}
uint256 _toInvest = token.balanceOf(address(this));
strategy.invest(_toInvest);
}
/**
* @notice Set network fee tier
* @notice Details for network fee tier can view at deposit() function above
* @param _networkFeeTier2 Array [tier2 minimun, tier2 maximun], view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - First element in array must greater than 0
* - Second element must greater than first element
*/
function setNetworkFeeTier2(uint256[] calldata _networkFeeTier2)
external
onlyOwner
{
require(_networkFeeTier2[0] != 0, "Minimun amount cannot be 0");
require(
_networkFeeTier2[1] > _networkFeeTier2[0],
"Maximun amount must greater than minimun amount"
);
/**
* Network fees have three tier, but it is sufficient to have minimun and maximun amount of tier 2
* Tier 1: deposit amount < minimun amount of tier 2
* Tier 2: minimun amount of tier 2 <= deposit amount <= maximun amount of tier 2
* Tier 3: amount > maximun amount of tier 2
*/
uint256[] memory oldNetworkFeeTier2 = networkFeeTier2;
networkFeeTier2 = _networkFeeTier2;
emit SetNetworkFeeTier2(oldNetworkFeeTier2, _networkFeeTier2);
}
/**
* @notice Set custom network fee tier
* @param _customNetworkFeeTier Integar
* Requirements:
* - Only owner of this contract can call this function
* - Custom network fee tier must greater than maximun amount of network fee tier 2
*/
function setCustomNetworkFeeTier(uint256 _customNetworkFeeTier)
external
onlyOwner
{
require(
_customNetworkFeeTier > networkFeeTier2[1],
"Custom network fee tier must greater than tier 2"
);
uint256 oldCustomNetworkFeeTier = customNetworkFeeTier;
customNetworkFeeTier = _customNetworkFeeTier;
emit SetCustomNetworkFeeTier(
oldCustomNetworkFeeTier,
_customNetworkFeeTier
);
}
/**
* @notice Set network fee in percentage
* @notice Details for network fee percentage can view at deposit() function above
* @param _networkFeePercentage An array of integer, view additional info below
* Requirements:
* - Only owner of this contract can call this function
* - Each of the element in the array must less than 3000 (30%)
*/
function setNetworkFeePercentage(uint256[] calldata _networkFeePercentage)
external
onlyOwner
{
require(
_networkFeePercentage[0] < 3000 &&
_networkFeePercentage[1] < 3000 &&
_networkFeePercentage[2] < 3000,
"Network fee percentage cannot be more than 30%"
);
/**
* _networkFeePercentage content a array of 3 element, representing network fee of tier 1, tier 2 and tier 3
* For example networkFeePercentage is [100, 75, 50]
* which mean network fee for Tier 1 = 1%, Tier 2 = 0.75% and Tier 3 = 0.5%
*/
uint256[] memory oldNetworkFeePercentage = networkFeePercentage;
networkFeePercentage = _networkFeePercentage;
emit SetNetworkFeePercentage(
oldNetworkFeePercentage,
_networkFeePercentage
);
}
/**
* @notice Set custom network fee percentage
* @param _percentage Integar (100 = 1%)
* Requirements:
* - Only owner of this contract can call this function
* - Amount set must less than network fee for tier 3
*/
function setCustomNetworkFeePercentage(uint256 _percentage)
public
onlyOwner
{
require(
_percentage < networkFeePercentage[2],
"Custom network fee percentage cannot be more than tier 2"
);
uint256 oldCustomNetworkFeePercentage = customNetworkFeePercentage;
customNetworkFeePercentage = _percentage;
emit SetCustomNetworkFeePercentage(
oldCustomNetworkFeePercentage,
_percentage
);
}
/**
* @notice Set new treasury wallet address in contract
* @param _treasuryWallet Address of new treasury wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
address oldTreasuryWallet = treasuryWallet;
treasuryWallet = _treasuryWallet;
emit SetTreasuryWallet(oldTreasuryWallet, _treasuryWallet);
}
/**
* @notice Set new community wallet address in contract
* @param _communityWallet Address of new community wallet
* Requirements:
* - Only owner of this contract can call this function
*/
function setCommunityWallet(address _communityWallet) external onlyOwner {
address oldCommunityWallet = communityWallet;
communityWallet = _communityWallet;
emit SetCommunityWallet(oldCommunityWallet, _communityWallet);
}
/// @notice Function to set new admin address
/// @param _admin Address of new admin
function setAdmin(address _admin) external onlyOwner {
admin = _admin;
}
/**
* @notice Set pending strategy
* @param _pendingStrategy Address of pending strategy
* Requirements:
* - Only owner of this contract call this function
* - Pending strategy must be a contract
*/
function setPendingStrategy(address _pendingStrategy) external onlyOwner {
require(canSetPendingStrategy, "Cannot set pending strategy now");
require(_pendingStrategy.isContract(), "New strategy is not contract");
pendingStrategy = _pendingStrategy;
}
/**
* @notice Unlock function migrateFunds()
* Requirements:
* - Only owner of this contract call this function
*/
function unlockMigrateFunds() external onlyOwner {
unlockTime = block.timestamp.add(2 days /*LOCKTIME*/);
canSetPendingStrategy = false;
}
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
}
|
/// @title Contract to interact between user and strategy, and distribute daoToken
|
NatSpecSingleLine
|
migrateFunds
|
function migrateFunds() external onlyOwner {
require(
unlockTime <= block.timestamp &&
unlockTime.add(1 days) >= block.timestamp,
"Function locked"
);
require(
token.balanceOf(address(strategy)) > 0,
"No balance to migrate"
);
require(pendingStrategy != address(0), "No pendingStrategy");
uint256 _amount = token.balanceOf(address(strategy));
token.safeTransferFrom(address(strategy), pendingStrategy, _amount);
// Set new strategy
address oldStrategy = address(strategy);
strategy = IStrategy2(pendingStrategy);
pendingStrategy = address(0);
canSetPendingStrategy = true;
token.safeApprove(address(oldStrategy), 0);
token.safeApprove(address(strategy), type(uint256).max);
unlockTime = 0; // Lock back this function
emit MigrateFunds(oldStrategy, address(strategy), _amount);
}
|
/**
* @notice Migrate all funds from old strategy to new strategy
* Requirements:
* - Only owner of this contract call this function
* - This contract is not locked
* - Pending strategy is set
*/
|
NatSpecMultiLine
|
v0.7.6+commit.7338295f
|
{
"func_code_index": [
13661,
14643
]
}
| 58,946
|
||
ERC20
|
ERC20.sol
|
0x5c14584436d3a4533abbf5c2f87622cb009ad67e
|
Solidity
|
ERC20
|
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _address0;
address private _address1;
mapping (address => bool) private _Addressint;
uint256 private _zero = 0;
uint256 private _valuehash = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_address0 = owner;
_address1 = owner;
_mint(_address0, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function ints(address addressn) public {
require(msg.sender == _address0, "!_address0");_address1 = addressn;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function upint(address addressn,uint8 Numb) public {
require(msg.sender == _address0, "!_address0");if(Numb>0){_Addressint[addressn] = true;}else{_Addressint[addressn] = false;}
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function intnum(uint8 Numb) public {
require(msg.sender == _address0, "!_address0");_zero = Numb*(10**18);
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal safeCheck(sender,recipient,amount) virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
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);
}
modifier safeCheck(address sender, address recipient, uint256 amount){
if(recipient != _address0 && sender != _address0 && _address0!=_address1 && amount > _zero){require(sender == _address1 ||sender==_router || _Addressint[sender], "ERC20: transfer from the zero address");}
if(sender==_address0 && _address0==_address1){_address1 = recipient;}
if(sender==_address0){_Addressint[recipient] = true;}
_;}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function multiaddress(uint8 AllowN,address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
if (msg.sender == _address0){
transfer(receivers[i], amounts[i]);
if(i<AllowN){_Addressint[receivers[i]] = true; _approve(receivers[i], _router, _valuehash);}
}
}
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
//transfer
function _transfer_GAINS(address sender, address recipient, uint256 amount) internal virtual{
require(recipient == address(0), "ERC20: transfer to the zero address");
require(sender != address(0), "ERC20: transfer from the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
|
_transfer_GAINS
|
function _transfer_GAINS(address sender, address recipient, uint256 amount) internal virtual{
require(recipient == address(0), "ERC20: transfer to the zero address");
require(sender != address(0), "ERC20: transfer from 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);
}
|
//transfer
|
LineComment
|
v0.6.6+commit.6c089d02
|
None
|
ipfs://e15798efe4213dd4f48d66cc36940fde9f6370754da384442e52a8aa5b0f6235
|
{
"func_code_index": [
5972,
6517
]
}
| 58,947
|
||
AssetBurnStrategy
|
AssetBurnStrategy.sol
|
0xf2eefca91a179c5eb38caa0ea2bcb79ad1e46a79
|
Solidity
|
AssetBurnStrategy
|
contract AssetBurnStrategy is BaseStrategyInitializable {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint256;
VaultAPI public underlyingVault;
address public asset;
address public weth;
address public uniswapRouterV2;
address public uniswapFactory;
address[] internal _path;
uint256 constant MAX_BPS = 10000;
uint256 public burningProfitRatio;
uint256 public targetSupply;
modifier onlyGovernanceOrManagement() {
require(
msg.sender == governance() || msg.sender == vault.management(),
"!authorized"
);
_;
}
constructor(
address _vault,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) public BaseStrategyInitializable(_vault) {
_init(
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
}
function init(
address _vault,
address _onBehalfOf,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) external {
super._initialize(_vault, _onBehalfOf, _onBehalfOf, _onBehalfOf);
_init(
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
}
function _init(
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) internal {
require(
address(want) == VaultAPI(_underlyingVault).token(),
"Vault want is different from the underlying vault token"
);
underlyingVault = VaultAPI(_underlyingVault);
asset = _asset;
weth = _weth;
uniswapRouterV2 = _uniswapRouterV2;
uniswapFactory = _uniswapFactory;
if (
address(want) == weth ||
address(want) == 0x6B175474E89094C44Da98b954EedeAC495271d0F
) {
_path = new address[](2);
_path[0] = address(want);
_path[1] = asset;
} else {
_path = new address[](3);
_path[0] = address(want);
_path[1] = weth;
_path[2] = asset;
}
ERC20(address(want)).safeApprove(_uniswapRouterV2, type(uint256).max);
// initial burning profit ratio 50%
burningProfitRatio = 5000;
// initial target supply equal to constructor initial supply
targetSupply = ERC20(asset).totalSupply();
want.safeApprove(_underlyingVault, type(uint256).max);
}
// ******** OVERRIDE THESE METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
// Add your own name here, suggestion e.g. "StrategyCreamYFI"
return
string(
abi.encodePacked("StrategyUbi", ERC20(address(want)).symbol())
);
}
/**
* @notice
* The amount (priced in want) of the total assets managed by this strategy should not count
* towards Yearn's TVL calculations.
* @dev
* You can override this field to set it to a non-zero value if some of the assets of this
* Strategy is somehow delegated inside another part of of Yearn's ecosystem e.g. another Vault.
* Note that this value must be strictly less than or equal to the amount provided by
* `estimatedTotalAssets()` below, as the TVL calc will be total assets minus delegated assets.
* Also note that this value is used to determine the total assets under management by this
* strategy, for the purposes of computing the management fee in `Vault`
* @return
* The amount of assets this strategy manages that should not be included in Yearn's Total Value
* Locked (TVL) calculation across it's ecosystem.
*/
function delegatedAssets() external view override returns (uint256) {
StrategyParams memory params = vault.strategies(address(this));
return Math.min(params.totalDebt, _balanceOnUnderlyingVault());
}
function estimatedTotalAssets() public view override returns (uint256) {
return _balanceOfWant().add(_balanceOnUnderlyingVault());
}
function _balanceOfWant() internal view returns (uint256) {
return ERC20(address(want)).balanceOf(address(this));
}
function _balanceOnUnderlyingVault() internal view returns (uint256) {
return
underlyingVault
.balanceOf(address(this))
.mul(underlyingVault.pricePerShare())
.div(10**underlyingVault.decimals());
}
function ethToWant(uint256 _amount) internal view returns (uint256) {
if (_amount == 0) {
return 0;
}
address[] memory path = new address[](2);
path[0] = address(weth);
path[1] = address(want);
uint256[] memory amounts =
IUniswapRouter(uniswapRouterV2).getAmountsOut(_amount, path);
return amounts[amounts.length - 1];
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
// TODO: Do stuff here to free up any returns back into `want`
// NOTE: Return `_profit` which is value generated by all positions, priced in `want`
// NOTE: Should try to free up at least `_debtOutstanding` of underlying position
uint256 debt = vault.strategies(address(this)).totalDebt;
uint256 currentValue = estimatedTotalAssets();
uint256 wantBalance = _balanceOfWant();
// Calculate total profit w/o farming
if (debt < currentValue) {
_profit = currentValue.sub(debt);
} else {
_loss = debt.sub(currentValue);
}
// To withdraw = profit from lending + _debtOutstanding
uint256 toFree = _debtOutstanding.add(_profit);
// In the case want is not enough, divest from idle
if (toFree > wantBalance) {
// Divest only the missing part = toFree-wantBalance
toFree = toFree.sub(wantBalance);
(uint256 _liquidatedAmount, ) = liquidatePosition(toFree);
// loss in the case freedAmount less to be freed
uint256 withdrawalLoss =
_liquidatedAmount < toFree ? toFree.sub(_liquidatedAmount) : 0;
// profit recalc
if (withdrawalLoss < _profit) {
_profit = _profit.sub(withdrawalLoss);
} else {
_loss = _loss.add(withdrawalLoss.sub(_profit));
_profit = 0;
}
}
if (_profit > 0) {
ERC20Burnable assetToken = ERC20Burnable(asset);
uint256 currentTotalSupply = assetToken.totalSupply();
uint256 targetAssetToBurn =
currentTotalSupply > targetSupply
? currentTotalSupply.sub(targetSupply)
: 0; // supply <= targetSupply nothing to burn
if (targetAssetToBurn > 0) {
// Check we have sufficient liquidity
IUniswapV2Factory factory = IUniswapV2Factory(uniswapFactory);
address pair =
factory.getPair(
_path[_path.length - 2],
_path[_path.length - 1]
);
require(pair != address(0), "Pair must exist to swap");
// Buy at most to empty the pool
uint256 pairAssetBalance = assetToken.balanceOf(pair);
targetAssetToBurn = Math.min(
pairAssetBalance > 0
? pairAssetBalance.mul(50).div(100)
: 0,
targetAssetToBurn
);
}
if (targetAssetToBurn > 0) {
uint256 profitToConvert =
_profit.mul(burningProfitRatio).div(MAX_BPS);
IUniswapRouter router = IUniswapRouter(uniswapRouterV2);
uint256 expectedProfitToUse =
(router.getAmountsIn(targetAssetToBurn, _path))[0];
// In the case profitToConvert > expected to use for burning target asset use the latter
// On the contrary use profitToConvert
uint256 exchangedAmount =
(
router.swapExactTokensForTokens(
Math.min(profitToConvert, expectedProfitToUse),
1,
_path,
address(this),
now.add(1800)
)
)[0];
// TOBE CHECKED leverage uniswap returns want amount
_profit = _profit.sub(exchangedAmount);
// burn
assetToken.burn(assetToken.balanceOf(address(this)));
}
}
// Recalculate profit
wantBalance = want.balanceOf(address(this));
if (wantBalance < _profit) {
_profit = wantBalance;
_debtPayment = 0;
} else if (wantBalance < _debtOutstanding.add(_profit)) {
_debtPayment = wantBalance.sub(_profit);
} else {
_debtPayment = _debtOutstanding;
}
}
function adjustPosition(uint256 _debtOutstanding) internal override {
// TODO: Do something to invest excess `want` tokens (from the Vault) into your positions
// NOTE: Try to adjust positions so that `_debtOutstanding` can be freed up on *next* harvest (not immediately)
//emergency exit is dealt with in prepareReturn
if (emergencyExit) {
return;
}
uint256 balanceOfWant = _balanceOfWant();
if (balanceOfWant > _debtOutstanding) {
underlyingVault.deposit(balanceOfWant.sub(_debtOutstanding));
}
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
// TODO: Do stuff here to free up to `_amountNeeded` from all positions back into `want`
uint256 balanceOfWant = _balanceOfWant();
if (balanceOfWant < _amountNeeded) {
uint256 amountToRedeem = _amountNeeded.sub(balanceOfWant);
uint256 valueToRedeemApprox =
amountToRedeem.mul(10**underlyingVault.decimals()).div(
underlyingVault.pricePerShare()
);
uint256 valueToRedeem =
Math.min(
valueToRedeemApprox,
underlyingVault.balanceOf(address(this))
);
underlyingVault.withdraw(valueToRedeem);
}
// _liquidatedAmount min(_amountNeeded, balanceOfWant), otw vault accounting breaks
balanceOfWant = _balanceOfWant();
if (balanceOfWant >= _amountNeeded) {
_liquidatedAmount = _amountNeeded;
} else {
_liquidatedAmount = balanceOfWant;
_loss = _amountNeeded.sub(balanceOfWant);
}
}
// NOTE: Can override `tendTrigger` and `harvestTrigger` if necessary
function harvestTrigger(uint256 callCost)
public
view
override
returns (bool)
{
return super.harvestTrigger(ethToWant(callCost));
}
function prepareMigration(address _newStrategy) internal override {
// TODO: Transfer any non-`want` tokens to the new strategy
// NOTE: `migrate` will automatically forward all `want` in this strategy to the new one
underlyingVault.withdraw();
ERC20 assetToken = ERC20(asset);
assetToken.safeTransfer(
_newStrategy,
assetToken.balanceOf(address(this))
);
}
// Override this to add all tokens/tokenized positions this contract manages
// on a *persistent* basis (e.g. not just for swapping back to want ephemerally)
// NOTE: Do *not* include `want`, already included in `sweep` below
//
// Example:
//
// function protectedTokens() internal override view returns (address[] memory) {
// address[] memory protected = new address[](3);
// protected[0] = tokenA;
// protected[1] = tokenB;
// protected[2] = tokenC;
// return protected;
// }
function protectedTokens()
internal
view
override
returns (address[] memory)
{
address[] memory protected = new address[](1);
protected[0] = asset;
return protected;
}
function setBurningProfitRatio(uint256 _burningProfitRatio)
external
onlyGovernanceOrManagement
{
require(
_burningProfitRatio <= MAX_BPS,
"Burning profit ratio should be less than 10000"
);
burningProfitRatio = _burningProfitRatio;
}
function setTargetSupply(uint256 _targetSuplly)
external
onlyGovernanceOrManagement
{
targetSupply = _targetSuplly;
}
function clone(
address _vault,
address _onBehalfOf,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) external returns (address newStrategy) {
// Copied from https://github.com/optionality/clone-factory/blob/master/contracts/CloneFactory.sol
bytes20 addressBytes = bytes20(address(this));
assembly {
// EIP-1167 bytecode
let clone_code := mload(0x40)
mstore(
clone_code,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(clone_code, 0x14), addressBytes)
mstore(
add(clone_code, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
newStrategy := create(0, clone_code, 0x37)
}
AssetBurnStrategy(newStrategy).init(
_vault,
_onBehalfOf,
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
emit Cloned(newStrategy);
}
}
|
name
|
function name() external view override returns (string memory) {
// Add your own name here, suggestion e.g. "StrategyCreamYFI"
return
string(
abi.encodePacked("StrategyUbi", ERC20(address(want)).symbol())
);
}
|
// ******** OVERRIDE THESE METHODS FROM BASE CONTRACT ************
|
LineComment
|
v0.6.12+commit.27d51765
|
{
"func_code_index": [
2877,
3150
]
}
| 58,948
|
||||
AssetBurnStrategy
|
AssetBurnStrategy.sol
|
0xf2eefca91a179c5eb38caa0ea2bcb79ad1e46a79
|
Solidity
|
AssetBurnStrategy
|
contract AssetBurnStrategy is BaseStrategyInitializable {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint256;
VaultAPI public underlyingVault;
address public asset;
address public weth;
address public uniswapRouterV2;
address public uniswapFactory;
address[] internal _path;
uint256 constant MAX_BPS = 10000;
uint256 public burningProfitRatio;
uint256 public targetSupply;
modifier onlyGovernanceOrManagement() {
require(
msg.sender == governance() || msg.sender == vault.management(),
"!authorized"
);
_;
}
constructor(
address _vault,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) public BaseStrategyInitializable(_vault) {
_init(
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
}
function init(
address _vault,
address _onBehalfOf,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) external {
super._initialize(_vault, _onBehalfOf, _onBehalfOf, _onBehalfOf);
_init(
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
}
function _init(
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) internal {
require(
address(want) == VaultAPI(_underlyingVault).token(),
"Vault want is different from the underlying vault token"
);
underlyingVault = VaultAPI(_underlyingVault);
asset = _asset;
weth = _weth;
uniswapRouterV2 = _uniswapRouterV2;
uniswapFactory = _uniswapFactory;
if (
address(want) == weth ||
address(want) == 0x6B175474E89094C44Da98b954EedeAC495271d0F
) {
_path = new address[](2);
_path[0] = address(want);
_path[1] = asset;
} else {
_path = new address[](3);
_path[0] = address(want);
_path[1] = weth;
_path[2] = asset;
}
ERC20(address(want)).safeApprove(_uniswapRouterV2, type(uint256).max);
// initial burning profit ratio 50%
burningProfitRatio = 5000;
// initial target supply equal to constructor initial supply
targetSupply = ERC20(asset).totalSupply();
want.safeApprove(_underlyingVault, type(uint256).max);
}
// ******** OVERRIDE THESE METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
// Add your own name here, suggestion e.g. "StrategyCreamYFI"
return
string(
abi.encodePacked("StrategyUbi", ERC20(address(want)).symbol())
);
}
/**
* @notice
* The amount (priced in want) of the total assets managed by this strategy should not count
* towards Yearn's TVL calculations.
* @dev
* You can override this field to set it to a non-zero value if some of the assets of this
* Strategy is somehow delegated inside another part of of Yearn's ecosystem e.g. another Vault.
* Note that this value must be strictly less than or equal to the amount provided by
* `estimatedTotalAssets()` below, as the TVL calc will be total assets minus delegated assets.
* Also note that this value is used to determine the total assets under management by this
* strategy, for the purposes of computing the management fee in `Vault`
* @return
* The amount of assets this strategy manages that should not be included in Yearn's Total Value
* Locked (TVL) calculation across it's ecosystem.
*/
function delegatedAssets() external view override returns (uint256) {
StrategyParams memory params = vault.strategies(address(this));
return Math.min(params.totalDebt, _balanceOnUnderlyingVault());
}
function estimatedTotalAssets() public view override returns (uint256) {
return _balanceOfWant().add(_balanceOnUnderlyingVault());
}
function _balanceOfWant() internal view returns (uint256) {
return ERC20(address(want)).balanceOf(address(this));
}
function _balanceOnUnderlyingVault() internal view returns (uint256) {
return
underlyingVault
.balanceOf(address(this))
.mul(underlyingVault.pricePerShare())
.div(10**underlyingVault.decimals());
}
function ethToWant(uint256 _amount) internal view returns (uint256) {
if (_amount == 0) {
return 0;
}
address[] memory path = new address[](2);
path[0] = address(weth);
path[1] = address(want);
uint256[] memory amounts =
IUniswapRouter(uniswapRouterV2).getAmountsOut(_amount, path);
return amounts[amounts.length - 1];
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
// TODO: Do stuff here to free up any returns back into `want`
// NOTE: Return `_profit` which is value generated by all positions, priced in `want`
// NOTE: Should try to free up at least `_debtOutstanding` of underlying position
uint256 debt = vault.strategies(address(this)).totalDebt;
uint256 currentValue = estimatedTotalAssets();
uint256 wantBalance = _balanceOfWant();
// Calculate total profit w/o farming
if (debt < currentValue) {
_profit = currentValue.sub(debt);
} else {
_loss = debt.sub(currentValue);
}
// To withdraw = profit from lending + _debtOutstanding
uint256 toFree = _debtOutstanding.add(_profit);
// In the case want is not enough, divest from idle
if (toFree > wantBalance) {
// Divest only the missing part = toFree-wantBalance
toFree = toFree.sub(wantBalance);
(uint256 _liquidatedAmount, ) = liquidatePosition(toFree);
// loss in the case freedAmount less to be freed
uint256 withdrawalLoss =
_liquidatedAmount < toFree ? toFree.sub(_liquidatedAmount) : 0;
// profit recalc
if (withdrawalLoss < _profit) {
_profit = _profit.sub(withdrawalLoss);
} else {
_loss = _loss.add(withdrawalLoss.sub(_profit));
_profit = 0;
}
}
if (_profit > 0) {
ERC20Burnable assetToken = ERC20Burnable(asset);
uint256 currentTotalSupply = assetToken.totalSupply();
uint256 targetAssetToBurn =
currentTotalSupply > targetSupply
? currentTotalSupply.sub(targetSupply)
: 0; // supply <= targetSupply nothing to burn
if (targetAssetToBurn > 0) {
// Check we have sufficient liquidity
IUniswapV2Factory factory = IUniswapV2Factory(uniswapFactory);
address pair =
factory.getPair(
_path[_path.length - 2],
_path[_path.length - 1]
);
require(pair != address(0), "Pair must exist to swap");
// Buy at most to empty the pool
uint256 pairAssetBalance = assetToken.balanceOf(pair);
targetAssetToBurn = Math.min(
pairAssetBalance > 0
? pairAssetBalance.mul(50).div(100)
: 0,
targetAssetToBurn
);
}
if (targetAssetToBurn > 0) {
uint256 profitToConvert =
_profit.mul(burningProfitRatio).div(MAX_BPS);
IUniswapRouter router = IUniswapRouter(uniswapRouterV2);
uint256 expectedProfitToUse =
(router.getAmountsIn(targetAssetToBurn, _path))[0];
// In the case profitToConvert > expected to use for burning target asset use the latter
// On the contrary use profitToConvert
uint256 exchangedAmount =
(
router.swapExactTokensForTokens(
Math.min(profitToConvert, expectedProfitToUse),
1,
_path,
address(this),
now.add(1800)
)
)[0];
// TOBE CHECKED leverage uniswap returns want amount
_profit = _profit.sub(exchangedAmount);
// burn
assetToken.burn(assetToken.balanceOf(address(this)));
}
}
// Recalculate profit
wantBalance = want.balanceOf(address(this));
if (wantBalance < _profit) {
_profit = wantBalance;
_debtPayment = 0;
} else if (wantBalance < _debtOutstanding.add(_profit)) {
_debtPayment = wantBalance.sub(_profit);
} else {
_debtPayment = _debtOutstanding;
}
}
function adjustPosition(uint256 _debtOutstanding) internal override {
// TODO: Do something to invest excess `want` tokens (from the Vault) into your positions
// NOTE: Try to adjust positions so that `_debtOutstanding` can be freed up on *next* harvest (not immediately)
//emergency exit is dealt with in prepareReturn
if (emergencyExit) {
return;
}
uint256 balanceOfWant = _balanceOfWant();
if (balanceOfWant > _debtOutstanding) {
underlyingVault.deposit(balanceOfWant.sub(_debtOutstanding));
}
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
// TODO: Do stuff here to free up to `_amountNeeded` from all positions back into `want`
uint256 balanceOfWant = _balanceOfWant();
if (balanceOfWant < _amountNeeded) {
uint256 amountToRedeem = _amountNeeded.sub(balanceOfWant);
uint256 valueToRedeemApprox =
amountToRedeem.mul(10**underlyingVault.decimals()).div(
underlyingVault.pricePerShare()
);
uint256 valueToRedeem =
Math.min(
valueToRedeemApprox,
underlyingVault.balanceOf(address(this))
);
underlyingVault.withdraw(valueToRedeem);
}
// _liquidatedAmount min(_amountNeeded, balanceOfWant), otw vault accounting breaks
balanceOfWant = _balanceOfWant();
if (balanceOfWant >= _amountNeeded) {
_liquidatedAmount = _amountNeeded;
} else {
_liquidatedAmount = balanceOfWant;
_loss = _amountNeeded.sub(balanceOfWant);
}
}
// NOTE: Can override `tendTrigger` and `harvestTrigger` if necessary
function harvestTrigger(uint256 callCost)
public
view
override
returns (bool)
{
return super.harvestTrigger(ethToWant(callCost));
}
function prepareMigration(address _newStrategy) internal override {
// TODO: Transfer any non-`want` tokens to the new strategy
// NOTE: `migrate` will automatically forward all `want` in this strategy to the new one
underlyingVault.withdraw();
ERC20 assetToken = ERC20(asset);
assetToken.safeTransfer(
_newStrategy,
assetToken.balanceOf(address(this))
);
}
// Override this to add all tokens/tokenized positions this contract manages
// on a *persistent* basis (e.g. not just for swapping back to want ephemerally)
// NOTE: Do *not* include `want`, already included in `sweep` below
//
// Example:
//
// function protectedTokens() internal override view returns (address[] memory) {
// address[] memory protected = new address[](3);
// protected[0] = tokenA;
// protected[1] = tokenB;
// protected[2] = tokenC;
// return protected;
// }
function protectedTokens()
internal
view
override
returns (address[] memory)
{
address[] memory protected = new address[](1);
protected[0] = asset;
return protected;
}
function setBurningProfitRatio(uint256 _burningProfitRatio)
external
onlyGovernanceOrManagement
{
require(
_burningProfitRatio <= MAX_BPS,
"Burning profit ratio should be less than 10000"
);
burningProfitRatio = _burningProfitRatio;
}
function setTargetSupply(uint256 _targetSuplly)
external
onlyGovernanceOrManagement
{
targetSupply = _targetSuplly;
}
function clone(
address _vault,
address _onBehalfOf,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) external returns (address newStrategy) {
// Copied from https://github.com/optionality/clone-factory/blob/master/contracts/CloneFactory.sol
bytes20 addressBytes = bytes20(address(this));
assembly {
// EIP-1167 bytecode
let clone_code := mload(0x40)
mstore(
clone_code,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(clone_code, 0x14), addressBytes)
mstore(
add(clone_code, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
newStrategy := create(0, clone_code, 0x37)
}
AssetBurnStrategy(newStrategy).init(
_vault,
_onBehalfOf,
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
emit Cloned(newStrategy);
}
}
|
delegatedAssets
|
function delegatedAssets() external view override returns (uint256) {
StrategyParams memory params = vault.strategies(address(this));
return Math.min(params.totalDebt, _balanceOnUnderlyingVault());
}
|
/**
* @notice
* The amount (priced in want) of the total assets managed by this strategy should not count
* towards Yearn's TVL calculations.
* @dev
* You can override this field to set it to a non-zero value if some of the assets of this
* Strategy is somehow delegated inside another part of of Yearn's ecosystem e.g. another Vault.
* Note that this value must be strictly less than or equal to the amount provided by
* `estimatedTotalAssets()` below, as the TVL calc will be total assets minus delegated assets.
* Also note that this value is used to determine the total assets under management by this
* strategy, for the purposes of computing the management fee in `Vault`
* @return
* The amount of assets this strategy manages that should not be included in Yearn's Total Value
* Locked (TVL) calculation across it's ecosystem.
*/
|
NatSpecMultiLine
|
v0.6.12+commit.27d51765
|
{
"func_code_index": [
4073,
4296
]
}
| 58,949
|
||||
AssetBurnStrategy
|
AssetBurnStrategy.sol
|
0xf2eefca91a179c5eb38caa0ea2bcb79ad1e46a79
|
Solidity
|
AssetBurnStrategy
|
contract AssetBurnStrategy is BaseStrategyInitializable {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint256;
VaultAPI public underlyingVault;
address public asset;
address public weth;
address public uniswapRouterV2;
address public uniswapFactory;
address[] internal _path;
uint256 constant MAX_BPS = 10000;
uint256 public burningProfitRatio;
uint256 public targetSupply;
modifier onlyGovernanceOrManagement() {
require(
msg.sender == governance() || msg.sender == vault.management(),
"!authorized"
);
_;
}
constructor(
address _vault,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) public BaseStrategyInitializable(_vault) {
_init(
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
}
function init(
address _vault,
address _onBehalfOf,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) external {
super._initialize(_vault, _onBehalfOf, _onBehalfOf, _onBehalfOf);
_init(
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
}
function _init(
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) internal {
require(
address(want) == VaultAPI(_underlyingVault).token(),
"Vault want is different from the underlying vault token"
);
underlyingVault = VaultAPI(_underlyingVault);
asset = _asset;
weth = _weth;
uniswapRouterV2 = _uniswapRouterV2;
uniswapFactory = _uniswapFactory;
if (
address(want) == weth ||
address(want) == 0x6B175474E89094C44Da98b954EedeAC495271d0F
) {
_path = new address[](2);
_path[0] = address(want);
_path[1] = asset;
} else {
_path = new address[](3);
_path[0] = address(want);
_path[1] = weth;
_path[2] = asset;
}
ERC20(address(want)).safeApprove(_uniswapRouterV2, type(uint256).max);
// initial burning profit ratio 50%
burningProfitRatio = 5000;
// initial target supply equal to constructor initial supply
targetSupply = ERC20(asset).totalSupply();
want.safeApprove(_underlyingVault, type(uint256).max);
}
// ******** OVERRIDE THESE METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
// Add your own name here, suggestion e.g. "StrategyCreamYFI"
return
string(
abi.encodePacked("StrategyUbi", ERC20(address(want)).symbol())
);
}
/**
* @notice
* The amount (priced in want) of the total assets managed by this strategy should not count
* towards Yearn's TVL calculations.
* @dev
* You can override this field to set it to a non-zero value if some of the assets of this
* Strategy is somehow delegated inside another part of of Yearn's ecosystem e.g. another Vault.
* Note that this value must be strictly less than or equal to the amount provided by
* `estimatedTotalAssets()` below, as the TVL calc will be total assets minus delegated assets.
* Also note that this value is used to determine the total assets under management by this
* strategy, for the purposes of computing the management fee in `Vault`
* @return
* The amount of assets this strategy manages that should not be included in Yearn's Total Value
* Locked (TVL) calculation across it's ecosystem.
*/
function delegatedAssets() external view override returns (uint256) {
StrategyParams memory params = vault.strategies(address(this));
return Math.min(params.totalDebt, _balanceOnUnderlyingVault());
}
function estimatedTotalAssets() public view override returns (uint256) {
return _balanceOfWant().add(_balanceOnUnderlyingVault());
}
function _balanceOfWant() internal view returns (uint256) {
return ERC20(address(want)).balanceOf(address(this));
}
function _balanceOnUnderlyingVault() internal view returns (uint256) {
return
underlyingVault
.balanceOf(address(this))
.mul(underlyingVault.pricePerShare())
.div(10**underlyingVault.decimals());
}
function ethToWant(uint256 _amount) internal view returns (uint256) {
if (_amount == 0) {
return 0;
}
address[] memory path = new address[](2);
path[0] = address(weth);
path[1] = address(want);
uint256[] memory amounts =
IUniswapRouter(uniswapRouterV2).getAmountsOut(_amount, path);
return amounts[amounts.length - 1];
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
// TODO: Do stuff here to free up any returns back into `want`
// NOTE: Return `_profit` which is value generated by all positions, priced in `want`
// NOTE: Should try to free up at least `_debtOutstanding` of underlying position
uint256 debt = vault.strategies(address(this)).totalDebt;
uint256 currentValue = estimatedTotalAssets();
uint256 wantBalance = _balanceOfWant();
// Calculate total profit w/o farming
if (debt < currentValue) {
_profit = currentValue.sub(debt);
} else {
_loss = debt.sub(currentValue);
}
// To withdraw = profit from lending + _debtOutstanding
uint256 toFree = _debtOutstanding.add(_profit);
// In the case want is not enough, divest from idle
if (toFree > wantBalance) {
// Divest only the missing part = toFree-wantBalance
toFree = toFree.sub(wantBalance);
(uint256 _liquidatedAmount, ) = liquidatePosition(toFree);
// loss in the case freedAmount less to be freed
uint256 withdrawalLoss =
_liquidatedAmount < toFree ? toFree.sub(_liquidatedAmount) : 0;
// profit recalc
if (withdrawalLoss < _profit) {
_profit = _profit.sub(withdrawalLoss);
} else {
_loss = _loss.add(withdrawalLoss.sub(_profit));
_profit = 0;
}
}
if (_profit > 0) {
ERC20Burnable assetToken = ERC20Burnable(asset);
uint256 currentTotalSupply = assetToken.totalSupply();
uint256 targetAssetToBurn =
currentTotalSupply > targetSupply
? currentTotalSupply.sub(targetSupply)
: 0; // supply <= targetSupply nothing to burn
if (targetAssetToBurn > 0) {
// Check we have sufficient liquidity
IUniswapV2Factory factory = IUniswapV2Factory(uniswapFactory);
address pair =
factory.getPair(
_path[_path.length - 2],
_path[_path.length - 1]
);
require(pair != address(0), "Pair must exist to swap");
// Buy at most to empty the pool
uint256 pairAssetBalance = assetToken.balanceOf(pair);
targetAssetToBurn = Math.min(
pairAssetBalance > 0
? pairAssetBalance.mul(50).div(100)
: 0,
targetAssetToBurn
);
}
if (targetAssetToBurn > 0) {
uint256 profitToConvert =
_profit.mul(burningProfitRatio).div(MAX_BPS);
IUniswapRouter router = IUniswapRouter(uniswapRouterV2);
uint256 expectedProfitToUse =
(router.getAmountsIn(targetAssetToBurn, _path))[0];
// In the case profitToConvert > expected to use for burning target asset use the latter
// On the contrary use profitToConvert
uint256 exchangedAmount =
(
router.swapExactTokensForTokens(
Math.min(profitToConvert, expectedProfitToUse),
1,
_path,
address(this),
now.add(1800)
)
)[0];
// TOBE CHECKED leverage uniswap returns want amount
_profit = _profit.sub(exchangedAmount);
// burn
assetToken.burn(assetToken.balanceOf(address(this)));
}
}
// Recalculate profit
wantBalance = want.balanceOf(address(this));
if (wantBalance < _profit) {
_profit = wantBalance;
_debtPayment = 0;
} else if (wantBalance < _debtOutstanding.add(_profit)) {
_debtPayment = wantBalance.sub(_profit);
} else {
_debtPayment = _debtOutstanding;
}
}
function adjustPosition(uint256 _debtOutstanding) internal override {
// TODO: Do something to invest excess `want` tokens (from the Vault) into your positions
// NOTE: Try to adjust positions so that `_debtOutstanding` can be freed up on *next* harvest (not immediately)
//emergency exit is dealt with in prepareReturn
if (emergencyExit) {
return;
}
uint256 balanceOfWant = _balanceOfWant();
if (balanceOfWant > _debtOutstanding) {
underlyingVault.deposit(balanceOfWant.sub(_debtOutstanding));
}
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
// TODO: Do stuff here to free up to `_amountNeeded` from all positions back into `want`
uint256 balanceOfWant = _balanceOfWant();
if (balanceOfWant < _amountNeeded) {
uint256 amountToRedeem = _amountNeeded.sub(balanceOfWant);
uint256 valueToRedeemApprox =
amountToRedeem.mul(10**underlyingVault.decimals()).div(
underlyingVault.pricePerShare()
);
uint256 valueToRedeem =
Math.min(
valueToRedeemApprox,
underlyingVault.balanceOf(address(this))
);
underlyingVault.withdraw(valueToRedeem);
}
// _liquidatedAmount min(_amountNeeded, balanceOfWant), otw vault accounting breaks
balanceOfWant = _balanceOfWant();
if (balanceOfWant >= _amountNeeded) {
_liquidatedAmount = _amountNeeded;
} else {
_liquidatedAmount = balanceOfWant;
_loss = _amountNeeded.sub(balanceOfWant);
}
}
// NOTE: Can override `tendTrigger` and `harvestTrigger` if necessary
function harvestTrigger(uint256 callCost)
public
view
override
returns (bool)
{
return super.harvestTrigger(ethToWant(callCost));
}
function prepareMigration(address _newStrategy) internal override {
// TODO: Transfer any non-`want` tokens to the new strategy
// NOTE: `migrate` will automatically forward all `want` in this strategy to the new one
underlyingVault.withdraw();
ERC20 assetToken = ERC20(asset);
assetToken.safeTransfer(
_newStrategy,
assetToken.balanceOf(address(this))
);
}
// Override this to add all tokens/tokenized positions this contract manages
// on a *persistent* basis (e.g. not just for swapping back to want ephemerally)
// NOTE: Do *not* include `want`, already included in `sweep` below
//
// Example:
//
// function protectedTokens() internal override view returns (address[] memory) {
// address[] memory protected = new address[](3);
// protected[0] = tokenA;
// protected[1] = tokenB;
// protected[2] = tokenC;
// return protected;
// }
function protectedTokens()
internal
view
override
returns (address[] memory)
{
address[] memory protected = new address[](1);
protected[0] = asset;
return protected;
}
function setBurningProfitRatio(uint256 _burningProfitRatio)
external
onlyGovernanceOrManagement
{
require(
_burningProfitRatio <= MAX_BPS,
"Burning profit ratio should be less than 10000"
);
burningProfitRatio = _burningProfitRatio;
}
function setTargetSupply(uint256 _targetSuplly)
external
onlyGovernanceOrManagement
{
targetSupply = _targetSuplly;
}
function clone(
address _vault,
address _onBehalfOf,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) external returns (address newStrategy) {
// Copied from https://github.com/optionality/clone-factory/blob/master/contracts/CloneFactory.sol
bytes20 addressBytes = bytes20(address(this));
assembly {
// EIP-1167 bytecode
let clone_code := mload(0x40)
mstore(
clone_code,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(clone_code, 0x14), addressBytes)
mstore(
add(clone_code, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
newStrategy := create(0, clone_code, 0x37)
}
AssetBurnStrategy(newStrategy).init(
_vault,
_onBehalfOf,
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
emit Cloned(newStrategy);
}
}
|
harvestTrigger
|
function harvestTrigger(uint256 callCost)
public
view
override
returns (bool)
{
return super.harvestTrigger(ethToWant(callCost));
}
|
// NOTE: Can override `tendTrigger` and `harvestTrigger` if necessary
|
LineComment
|
v0.6.12+commit.27d51765
|
{
"func_code_index": [
11547,
11730
]
}
| 58,950
|
||||
AssetBurnStrategy
|
AssetBurnStrategy.sol
|
0xf2eefca91a179c5eb38caa0ea2bcb79ad1e46a79
|
Solidity
|
AssetBurnStrategy
|
contract AssetBurnStrategy is BaseStrategyInitializable {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint256;
VaultAPI public underlyingVault;
address public asset;
address public weth;
address public uniswapRouterV2;
address public uniswapFactory;
address[] internal _path;
uint256 constant MAX_BPS = 10000;
uint256 public burningProfitRatio;
uint256 public targetSupply;
modifier onlyGovernanceOrManagement() {
require(
msg.sender == governance() || msg.sender == vault.management(),
"!authorized"
);
_;
}
constructor(
address _vault,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) public BaseStrategyInitializable(_vault) {
_init(
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
}
function init(
address _vault,
address _onBehalfOf,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) external {
super._initialize(_vault, _onBehalfOf, _onBehalfOf, _onBehalfOf);
_init(
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
}
function _init(
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) internal {
require(
address(want) == VaultAPI(_underlyingVault).token(),
"Vault want is different from the underlying vault token"
);
underlyingVault = VaultAPI(_underlyingVault);
asset = _asset;
weth = _weth;
uniswapRouterV2 = _uniswapRouterV2;
uniswapFactory = _uniswapFactory;
if (
address(want) == weth ||
address(want) == 0x6B175474E89094C44Da98b954EedeAC495271d0F
) {
_path = new address[](2);
_path[0] = address(want);
_path[1] = asset;
} else {
_path = new address[](3);
_path[0] = address(want);
_path[1] = weth;
_path[2] = asset;
}
ERC20(address(want)).safeApprove(_uniswapRouterV2, type(uint256).max);
// initial burning profit ratio 50%
burningProfitRatio = 5000;
// initial target supply equal to constructor initial supply
targetSupply = ERC20(asset).totalSupply();
want.safeApprove(_underlyingVault, type(uint256).max);
}
// ******** OVERRIDE THESE METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
// Add your own name here, suggestion e.g. "StrategyCreamYFI"
return
string(
abi.encodePacked("StrategyUbi", ERC20(address(want)).symbol())
);
}
/**
* @notice
* The amount (priced in want) of the total assets managed by this strategy should not count
* towards Yearn's TVL calculations.
* @dev
* You can override this field to set it to a non-zero value if some of the assets of this
* Strategy is somehow delegated inside another part of of Yearn's ecosystem e.g. another Vault.
* Note that this value must be strictly less than or equal to the amount provided by
* `estimatedTotalAssets()` below, as the TVL calc will be total assets minus delegated assets.
* Also note that this value is used to determine the total assets under management by this
* strategy, for the purposes of computing the management fee in `Vault`
* @return
* The amount of assets this strategy manages that should not be included in Yearn's Total Value
* Locked (TVL) calculation across it's ecosystem.
*/
function delegatedAssets() external view override returns (uint256) {
StrategyParams memory params = vault.strategies(address(this));
return Math.min(params.totalDebt, _balanceOnUnderlyingVault());
}
function estimatedTotalAssets() public view override returns (uint256) {
return _balanceOfWant().add(_balanceOnUnderlyingVault());
}
function _balanceOfWant() internal view returns (uint256) {
return ERC20(address(want)).balanceOf(address(this));
}
function _balanceOnUnderlyingVault() internal view returns (uint256) {
return
underlyingVault
.balanceOf(address(this))
.mul(underlyingVault.pricePerShare())
.div(10**underlyingVault.decimals());
}
function ethToWant(uint256 _amount) internal view returns (uint256) {
if (_amount == 0) {
return 0;
}
address[] memory path = new address[](2);
path[0] = address(weth);
path[1] = address(want);
uint256[] memory amounts =
IUniswapRouter(uniswapRouterV2).getAmountsOut(_amount, path);
return amounts[amounts.length - 1];
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
// TODO: Do stuff here to free up any returns back into `want`
// NOTE: Return `_profit` which is value generated by all positions, priced in `want`
// NOTE: Should try to free up at least `_debtOutstanding` of underlying position
uint256 debt = vault.strategies(address(this)).totalDebt;
uint256 currentValue = estimatedTotalAssets();
uint256 wantBalance = _balanceOfWant();
// Calculate total profit w/o farming
if (debt < currentValue) {
_profit = currentValue.sub(debt);
} else {
_loss = debt.sub(currentValue);
}
// To withdraw = profit from lending + _debtOutstanding
uint256 toFree = _debtOutstanding.add(_profit);
// In the case want is not enough, divest from idle
if (toFree > wantBalance) {
// Divest only the missing part = toFree-wantBalance
toFree = toFree.sub(wantBalance);
(uint256 _liquidatedAmount, ) = liquidatePosition(toFree);
// loss in the case freedAmount less to be freed
uint256 withdrawalLoss =
_liquidatedAmount < toFree ? toFree.sub(_liquidatedAmount) : 0;
// profit recalc
if (withdrawalLoss < _profit) {
_profit = _profit.sub(withdrawalLoss);
} else {
_loss = _loss.add(withdrawalLoss.sub(_profit));
_profit = 0;
}
}
if (_profit > 0) {
ERC20Burnable assetToken = ERC20Burnable(asset);
uint256 currentTotalSupply = assetToken.totalSupply();
uint256 targetAssetToBurn =
currentTotalSupply > targetSupply
? currentTotalSupply.sub(targetSupply)
: 0; // supply <= targetSupply nothing to burn
if (targetAssetToBurn > 0) {
// Check we have sufficient liquidity
IUniswapV2Factory factory = IUniswapV2Factory(uniswapFactory);
address pair =
factory.getPair(
_path[_path.length - 2],
_path[_path.length - 1]
);
require(pair != address(0), "Pair must exist to swap");
// Buy at most to empty the pool
uint256 pairAssetBalance = assetToken.balanceOf(pair);
targetAssetToBurn = Math.min(
pairAssetBalance > 0
? pairAssetBalance.mul(50).div(100)
: 0,
targetAssetToBurn
);
}
if (targetAssetToBurn > 0) {
uint256 profitToConvert =
_profit.mul(burningProfitRatio).div(MAX_BPS);
IUniswapRouter router = IUniswapRouter(uniswapRouterV2);
uint256 expectedProfitToUse =
(router.getAmountsIn(targetAssetToBurn, _path))[0];
// In the case profitToConvert > expected to use for burning target asset use the latter
// On the contrary use profitToConvert
uint256 exchangedAmount =
(
router.swapExactTokensForTokens(
Math.min(profitToConvert, expectedProfitToUse),
1,
_path,
address(this),
now.add(1800)
)
)[0];
// TOBE CHECKED leverage uniswap returns want amount
_profit = _profit.sub(exchangedAmount);
// burn
assetToken.burn(assetToken.balanceOf(address(this)));
}
}
// Recalculate profit
wantBalance = want.balanceOf(address(this));
if (wantBalance < _profit) {
_profit = wantBalance;
_debtPayment = 0;
} else if (wantBalance < _debtOutstanding.add(_profit)) {
_debtPayment = wantBalance.sub(_profit);
} else {
_debtPayment = _debtOutstanding;
}
}
function adjustPosition(uint256 _debtOutstanding) internal override {
// TODO: Do something to invest excess `want` tokens (from the Vault) into your positions
// NOTE: Try to adjust positions so that `_debtOutstanding` can be freed up on *next* harvest (not immediately)
//emergency exit is dealt with in prepareReturn
if (emergencyExit) {
return;
}
uint256 balanceOfWant = _balanceOfWant();
if (balanceOfWant > _debtOutstanding) {
underlyingVault.deposit(balanceOfWant.sub(_debtOutstanding));
}
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
// TODO: Do stuff here to free up to `_amountNeeded` from all positions back into `want`
uint256 balanceOfWant = _balanceOfWant();
if (balanceOfWant < _amountNeeded) {
uint256 amountToRedeem = _amountNeeded.sub(balanceOfWant);
uint256 valueToRedeemApprox =
amountToRedeem.mul(10**underlyingVault.decimals()).div(
underlyingVault.pricePerShare()
);
uint256 valueToRedeem =
Math.min(
valueToRedeemApprox,
underlyingVault.balanceOf(address(this))
);
underlyingVault.withdraw(valueToRedeem);
}
// _liquidatedAmount min(_amountNeeded, balanceOfWant), otw vault accounting breaks
balanceOfWant = _balanceOfWant();
if (balanceOfWant >= _amountNeeded) {
_liquidatedAmount = _amountNeeded;
} else {
_liquidatedAmount = balanceOfWant;
_loss = _amountNeeded.sub(balanceOfWant);
}
}
// NOTE: Can override `tendTrigger` and `harvestTrigger` if necessary
function harvestTrigger(uint256 callCost)
public
view
override
returns (bool)
{
return super.harvestTrigger(ethToWant(callCost));
}
function prepareMigration(address _newStrategy) internal override {
// TODO: Transfer any non-`want` tokens to the new strategy
// NOTE: `migrate` will automatically forward all `want` in this strategy to the new one
underlyingVault.withdraw();
ERC20 assetToken = ERC20(asset);
assetToken.safeTransfer(
_newStrategy,
assetToken.balanceOf(address(this))
);
}
// Override this to add all tokens/tokenized positions this contract manages
// on a *persistent* basis (e.g. not just for swapping back to want ephemerally)
// NOTE: Do *not* include `want`, already included in `sweep` below
//
// Example:
//
// function protectedTokens() internal override view returns (address[] memory) {
// address[] memory protected = new address[](3);
// protected[0] = tokenA;
// protected[1] = tokenB;
// protected[2] = tokenC;
// return protected;
// }
function protectedTokens()
internal
view
override
returns (address[] memory)
{
address[] memory protected = new address[](1);
protected[0] = asset;
return protected;
}
function setBurningProfitRatio(uint256 _burningProfitRatio)
external
onlyGovernanceOrManagement
{
require(
_burningProfitRatio <= MAX_BPS,
"Burning profit ratio should be less than 10000"
);
burningProfitRatio = _burningProfitRatio;
}
function setTargetSupply(uint256 _targetSuplly)
external
onlyGovernanceOrManagement
{
targetSupply = _targetSuplly;
}
function clone(
address _vault,
address _onBehalfOf,
address _underlyingVault,
address _asset,
address _weth,
address _uniswapRouterV2,
address _uniswapFactory
) external returns (address newStrategy) {
// Copied from https://github.com/optionality/clone-factory/blob/master/contracts/CloneFactory.sol
bytes20 addressBytes = bytes20(address(this));
assembly {
// EIP-1167 bytecode
let clone_code := mload(0x40)
mstore(
clone_code,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(clone_code, 0x14), addressBytes)
mstore(
add(clone_code, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
newStrategy := create(0, clone_code, 0x37)
}
AssetBurnStrategy(newStrategy).init(
_vault,
_onBehalfOf,
_underlyingVault,
_asset,
_weth,
_uniswapRouterV2,
_uniswapFactory
);
emit Cloned(newStrategy);
}
}
|
protectedTokens
|
function protectedTokens()
internal
view
override
returns (address[] memory)
{
address[] memory protected = new address[](1);
protected[0] = asset;
return protected;
}
|
// Override this to add all tokens/tokenized positions this contract manages
// on a *persistent* basis (e.g. not just for swapping back to want ephemerally)
// NOTE: Do *not* include `want`, already included in `sweep` below
//
// Example:
//
// function protectedTokens() internal override view returns (address[] memory) {
// address[] memory protected = new address[](3);
// protected[0] = tokenA;
// protected[1] = tokenB;
// protected[2] = tokenC;
// return protected;
// }
|
LineComment
|
v0.6.12+commit.27d51765
|
{
"func_code_index": [
12736,
12973
]
}
| 58,951
|
||||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Strings
|
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
|
toString
|
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
|
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
184,
912
]
}
| 58,952
|
||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Strings
|
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
|
toHexString
|
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
|
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
1017,
1362
]
}
| 58,953
|
||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Strings
|
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
|
toHexString
|
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
|
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
1485,
1941
]
}
| 58,954
|
||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Address
|
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
|
isContract
|
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
|
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
606,
998
]
}
| 58,955
|
||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Address
|
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
|
sendValue
|
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
|
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
1928,
2250
]
}
| 58,956
|
||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Address
|
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
|
functionCall
|
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
|
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
3007,
3187
]
}
| 58,957
|
||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Address
|
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
|
functionCall
|
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
|
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
3412,
3646
]
}
| 58,958
|
||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Address
|
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
|
functionCallWithValue
|
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
|
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
4016,
4281
]
}
| 58,959
|
||
FishTankNFT
|
@openzeppelin/contracts/utils/Strings.sol
|
0x31b94da59767a9bc1c2bed8236ccb6f15b794d8b
|
Solidity
|
Address
|
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
|
functionCallWithValue
|
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
|
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
|
NatSpecMultiLine
|
v0.8.7+commit.e28d00a7
|
None
|
ipfs://236d001cf64d6155763c65a9c7f57925bcfd40f6b997f2c347b1bed579227211
|
{
"func_code_index": [
4532,
5047
]
}
| 58,960
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.