Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 12888213 | 1131 days ago | IN | 0 ETH | 0.01550462 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
ASAP
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity Multiple files format)
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; import "./Include.sol"; contract ASAP is PermitERC20UpgradeSafe { function __ASAP_init(address mine_, address eco_, address team_, address contribution_, address liqudity_, address public_, address airdrop_) external initializer { __Context_init_unchained(); __ERC20_init_unchained("ChainSwap.com Governance Token", "ASAP"); __ASAP_init_unchained(mine_, eco_, team_, contribution_, liqudity_, public_, airdrop_); } function __ASAP_init_unchained(address mine_, address eco_, address team_, address contribution_, address liqudity_, address public_, address airdrop_) public initializer { _mint(mine_, 50_000_000 * 10 ** uint256(decimals())); _mint(eco_, 10_000_000 * 10 ** uint256(decimals())); _mint(team_, 10_000_000 * 10 ** uint256(decimals())); _mint(contribution_, 20_000_000 * 10 ** uint256(decimals())); _mint(liqudity_, 8_000_000 * 10 ** uint256(decimals())); _mint(public_, 1_000_000 * 10 ** uint256(decimals())); _mint(airdrop_, 1_000_000 * 10 ** uint256(decimals())); } } contract ASAPING is ERC20UpgradeSafe, Configurable { using SafeERC20 for IERC20; address public token; uint public firstTime; uint public firstRatio; uint public begin; uint public end; mapping (address => uint) internal _beginBalances; function __ASAPING_init(address governor_, address token_) public initializer { __Governable_init_unchained(governor_); __Context_init_unchained(); __ERC20_init_unchained("ChainSwap.com ASAP locking", "ASAPING"); //_setupDecimals(18); token = token_; } function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override { if(from != address(0) && to != address(0)) { uint beginAmount = amount.mul(_beginBalances[from]).div(_balances[from]); _beginBalances[from] = _beginBalances[from].sub(beginAmount); _beginBalances[to] = _beginBalances[to].add(beginAmount); }else if(to != address(0)) // _mint _beginBalances[to] = _beginBalances[to].add(amount); } function startUnlock(address recipient, uint _firstTime, uint _firstRatio, uint _begin, uint _end) external governance { require(_firstRatio <= 1e18); require(_begin <= _end); _setupDecimals(ERC20UpgradeSafe(token).decimals()); _mint(recipient, IERC20(token).balanceOf(address(this)).sub(_totalSupply)); firstTime = _firstTime; firstRatio = _firstRatio; begin = _begin; end = _end; } function unlockCapacity(address holder) public view returns (uint) { if(now < firstTime) return 0; return _balances[holder].sub(_beginBalances[holder].mul(uint(1e18).sub(firstRatio)).div(1e18).mul(end.sub(Math.min(Math.max(begin, now), end))).div(end.sub(begin))); } function unlock() public { uint amount = unlockCapacity(msg.sender); _burn(msg.sender, amount); IERC20(token).safeTransfer(msg.sender, amount); } fallback() external { unlock(); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; contract PlaceHolder { } /** * @title Proxy * @dev Implements delegation of calls to other contracts, with proper * forwarding of return values and bubbling of failures. * It defines a fallback function that delegates all calls to the address * returned by the abstract _implementation() internal function. */ abstract contract Proxy { /** * @dev Fallback function. * Implemented entirely in `_fallback`. */ fallback () payable external { _fallback(); } receive () virtual payable external { _fallback(); } /** * @return The Address of the implementation. */ function _implementation() virtual internal view returns (address); /** * @dev Delegates execution to an implementation contract. * This is a low level function that doesn't return to its internal call site. * It will return to the external caller whatever the implementation returns. * @param implementation Address to delegate. */ function _delegate(address implementation) internal { assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } /** * @dev Function that is run as the first thing in the fallback function. * Can be redefined in derived contracts to add functionality. * Redefinitions must call super._willFallback(). */ function _willFallback() virtual internal { } /** * @dev fallback implementation. * Extracted to enable manual triggering. */ function _fallback() internal { if(OpenZeppelinUpgradesAddress.isContract(msg.sender) && msg.data.length == 0 && gasleft() <= 2300) // for receive ETH only from other contract return; _willFallback(); _delegate(_implementation()); } } /** * @title BaseUpgradeabilityProxy * @dev This contract implements a proxy that allows to change the * implementation address to which it will delegate. * Such a change is called an implementation upgrade. */ abstract contract BaseUpgradeabilityProxy is Proxy { /** * @dev Emitted when the implementation is upgraded. * @param implementation Address of the new implementation. */ event Upgraded(address indexed implementation); /** * @dev Storage slot with the address of the current implementation. * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /** * @dev Returns the current implementation. * @return impl Address of the current implementation */ function _implementation() virtual override internal view returns (address impl) { bytes32 slot = IMPLEMENTATION_SLOT; assembly { impl := sload(slot) } } /** * @dev Upgrades the proxy to a new implementation. * @param newImplementation Address of the new implementation. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Sets the implementation address of the proxy. * @param newImplementation Address of the new implementation. */ function _setImplementation(address newImplementation) internal { require(newImplementation == address(0) || OpenZeppelinUpgradesAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address"); bytes32 slot = IMPLEMENTATION_SLOT; assembly { sstore(slot, newImplementation) } } } /** * @title BaseAdminUpgradeabilityProxy * @dev This contract combines an upgradeability proxy with an authorization * mechanism for administrative tasks. * All external functions in this contract must be guarded by the * `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity * feature proposal that would enable this to be done automatically. */ contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Emitted when the administration has been transferred. * @param previousAdmin Address of the previous admin. * @param newAdmin Address of the new admin. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Modifier to check whether the `msg.sender` is the admin. * If it is, it will run the function. Otherwise, it will delegate the call * to the implementation. */ modifier ifAdmin() { if (msg.sender == _admin()) { _; } else { _fallback(); } } /** * @return The address of the proxy admin. */ function admin() external ifAdmin returns (address) { return _admin(); } /** * @return The address of the implementation. */ function implementation() external ifAdmin returns (address) { return _implementation(); } /** * @dev Changes the admin of the proxy. * Only the current admin can call this function. * @param newAdmin Address to transfer proxy administration to. */ function changeAdmin(address newAdmin) external ifAdmin { require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address"); emit AdminChanged(_admin(), newAdmin); _setAdmin(newAdmin); } /** * @dev Upgrade the backing implementation of the proxy. * Only the admin can call this function. * @param newImplementation Address of the new implementation. */ function upgradeTo(address newImplementation) external ifAdmin { _upgradeTo(newImplementation); } /** * @dev Upgrade the backing implementation of the proxy and call a function * on the new implementation. * This is useful to initialize the proxied contract. * @param newImplementation Address of the new implementation. * @param data Data to send as msg.data in the low level call. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. */ function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin { _upgradeTo(newImplementation); (bool success,) = newImplementation.delegatecall(data); require(success); } /** * @return adm The admin slot. */ function _admin() internal view returns (address adm) { bytes32 slot = ADMIN_SLOT; assembly { adm := sload(slot) } } /** * @dev Sets the address of the proxy admin. * @param newAdmin Address of the new proxy admin. */ function _setAdmin(address newAdmin) internal { bytes32 slot = ADMIN_SLOT; assembly { sstore(slot, newAdmin) } } /** * @dev Only fall back when the sender is not the admin. */ function _willFallback() virtual override internal { require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin"); //super._willFallback(); } } interface IAdminUpgradeabilityProxyView { function admin() external view returns (address); function implementation() external view returns (address); } /** * @title UpgradeabilityProxy * @dev Extends BaseUpgradeabilityProxy with a constructor for initializing * implementation and init data. */ abstract contract UpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Contract constructor. * @param _logic Address of the initial implementation. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ constructor(address _logic, bytes memory _data) public payable { assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)); _setImplementation(_logic); if(_data.length > 0) { (bool success,) = _logic.delegatecall(_data); require(success); } } //function _willFallback() virtual override internal { //super._willFallback(); //} } /** * @title AdminUpgradeabilityProxy * @dev Extends from BaseAdminUpgradeabilityProxy with a constructor for * initializing the implementation, admin, and init data. */ contract AdminUpgradeabilityProxy is BaseAdminUpgradeabilityProxy, UpgradeabilityProxy { /** * Contract constructor. * @param _logic address of the initial implementation. * @param _admin Address of the proxy administrator. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ constructor(address _logic, address _admin, bytes memory _data) UpgradeabilityProxy(_logic, _data) public payable { assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)); _setAdmin(_admin); } function _willFallback() override(Proxy, BaseAdminUpgradeabilityProxy) internal { super._willFallback(); } } /** * @title BaseAdminUpgradeabilityProxy * @dev This contract combines an upgradeability proxy with an authorization * mechanism for administrative tasks. * All external functions in this contract must be guarded by the * `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity * feature proposal that would enable this to be done automatically. */ contract __BaseAdminUpgradeabilityProxy__ is BaseUpgradeabilityProxy { /** * @dev Emitted when the administration has been transferred. * @param previousAdmin Address of the previous admin. * @param newAdmin Address of the new admin. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Modifier to check whether the `msg.sender` is the admin. * If it is, it will run the function. Otherwise, it will delegate the call * to the implementation. */ //modifier ifAdmin() { // if (msg.sender == _admin()) { // _; // } else { // _fallback(); // } //} modifier ifAdmin() { require (msg.sender == _admin(), 'only admin'); _; } /** * @return The address of the proxy admin. */ //function admin() external ifAdmin returns (address) { // return _admin(); //} function __admin__() external view returns (address) { return _admin(); } /** * @return The address of the implementation. */ //function implementation() external ifAdmin returns (address) { // return _implementation(); //} function __implementation__() external view returns (address) { return _implementation(); } /** * @dev Changes the admin of the proxy. * Only the current admin can call this function. * @param newAdmin Address to transfer proxy administration to. */ //function changeAdmin(address newAdmin) external ifAdmin { // require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address"); // emit AdminChanged(_admin(), newAdmin); // _setAdmin(newAdmin); //} function __changeAdmin__(address newAdmin) external ifAdmin { require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address"); emit AdminChanged(_admin(), newAdmin); _setAdmin(newAdmin); } /** * @dev Upgrade the backing implementation of the proxy. * Only the admin can call this function. * @param newImplementation Address of the new implementation. */ //function upgradeTo(address newImplementation) external ifAdmin { // _upgradeTo(newImplementation); //} function __upgradeTo__(address newImplementation) external ifAdmin { _upgradeTo(newImplementation); } /** * @dev Upgrade the backing implementation of the proxy and call a function * on the new implementation. * This is useful to initialize the proxied contract. * @param newImplementation Address of the new implementation. * @param data Data to send as msg.data in the low level call. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. */ //function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin { // _upgradeTo(newImplementation); // (bool success,) = newImplementation.delegatecall(data); // require(success); //} function __upgradeToAndCall__(address newImplementation, bytes calldata data) payable external ifAdmin { _upgradeTo(newImplementation); (bool success,) = newImplementation.delegatecall(data); require(success); } /** * @return adm The admin slot. */ function _admin() internal view returns (address adm) { bytes32 slot = ADMIN_SLOT; assembly { adm := sload(slot) } } /** * @dev Sets the address of the proxy admin. * @param newAdmin Address of the new proxy admin. */ function _setAdmin(address newAdmin) internal { bytes32 slot = ADMIN_SLOT; assembly { sstore(slot, newAdmin) } } /** * @dev Only fall back when the sender is not the admin. */ //function _willFallback() virtual override internal { // require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin"); // //super._willFallback(); //} } /** * @title AdminUpgradeabilityProxy * @dev Extends from BaseAdminUpgradeabilityProxy with a constructor for * initializing the implementation, admin, and init data. */ contract __AdminUpgradeabilityProxy__ is __BaseAdminUpgradeabilityProxy__, UpgradeabilityProxy { /** * Contract constructor. * @param _logic address of the initial implementation. * @param _admin Address of the proxy administrator. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ constructor(address _logic, address _admin, bytes memory _data) UpgradeabilityProxy(_logic, _data) public payable { assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)); _setAdmin(_admin); } //function _willFallback() override(Proxy, BaseAdminUpgradeabilityProxy) internal { // super._willFallback(); //} } /** * @title InitializableUpgradeabilityProxy * @dev Extends BaseUpgradeabilityProxy with an initializer for initializing * implementation and init data. */ abstract contract InitializableUpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Contract initializer. * @param _logic Address of the initial implementation. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ function initialize(address _logic, bytes memory _data) public payable { require(_implementation() == address(0)); assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)); _setImplementation(_logic); if(_data.length > 0) { (bool success,) = _logic.delegatecall(_data); require(success); } } } /** * @title InitializableAdminUpgradeabilityProxy * @dev Extends from BaseAdminUpgradeabilityProxy with an initializer for * initializing the implementation, admin, and init data. */ contract InitializableAdminUpgradeabilityProxy is BaseAdminUpgradeabilityProxy, InitializableUpgradeabilityProxy { /** * Contract initializer. * @param _logic address of the initial implementation. * @param _admin Address of the proxy administrator. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ function initialize(address _logic, address _admin, bytes memory _data) public payable { require(_implementation() == address(0)); InitializableUpgradeabilityProxy.initialize(_logic, _data); assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)); _setAdmin(_admin); } function _willFallback() override(Proxy, BaseAdminUpgradeabilityProxy) internal { super._willFallback(); } } interface IProxyFactory { function governor() external view returns (address); function __admin__() external view returns (address); function productImplementation() external view returns (address); function productImplementations(bytes32 name) external view returns (address); } /** * @title ProductProxy * @dev This contract implements a proxy that * it is deploied by ProxyFactory, * and it's implementation is stored in factory. */ contract ProductProxy is Proxy { /** * @dev Storage slot with the address of the ProxyFactory. * This is the keccak-256 hash of "eip1967.proxy.factory" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant FACTORY_SLOT = 0x7a45a402e4cb6e08ebc196f20f66d5d30e67285a2a8aa80503fa409e727a4af1; bytes32 internal constant NAME_SLOT = 0x4cd9b827ca535ceb0880425d70eff88561ecdf04dc32fcf7ff3b15c587f8a870; // bytes32(uint256(keccak256('eip1967.proxy.name')) - 1) function _name() virtual internal view returns (bytes32 name_) { bytes32 slot = NAME_SLOT; assembly { name_ := sload(slot) } } function _setName(bytes32 name_) internal { bytes32 slot = NAME_SLOT; assembly { sstore(slot, name_) } } /** * @dev Sets the factory address of the ProductProxy. * @param newFactory Address of the new factory. */ function _setFactory(address newFactory) internal { require(newFactory == address(0) || OpenZeppelinUpgradesAddress.isContract(newFactory), "Cannot set a factory to a non-contract address"); bytes32 slot = FACTORY_SLOT; assembly { sstore(slot, newFactory) } } /** * @dev Returns the factory. * @return factory_ Address of the factory. */ function _factory() internal view returns (address factory_) { bytes32 slot = FACTORY_SLOT; assembly { factory_ := sload(slot) } } /** * @dev Returns the current implementation. * @return Address of the current implementation */ function _implementation() virtual override internal view returns (address) { address factory_ = _factory(); bytes32 name_ = _name(); if(OpenZeppelinUpgradesAddress.isContract(factory_)) if(name_ != 0x0) return IProxyFactory(factory_).productImplementations(name_); else return IProxyFactory(factory_).productImplementation(); else return address(0); } } /** * @title InitializableProductProxy * @dev Extends ProductProxy with an initializer for initializing * factory and init data. */ contract InitializableProductProxy is ProductProxy { /** * @dev Contract initializer. * @param factory Address of the initial factory. * @param data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ function __InitializableProductProxy_init(address factory, bytes32 name, bytes memory data) external payable { address factory_ = _factory(); require(factory_ == address(0) || msg.sender == factory_ || msg.sender == IProxyFactory(factory_).governor() || msg.sender == IProxyFactory(factory_).__admin__()); assert(FACTORY_SLOT == bytes32(uint256(keccak256('eip1967.proxy.factory')) - 1)); assert(NAME_SLOT == bytes32(uint256(keccak256('eip1967.proxy.name')) - 1)); _setFactory(factory); _setName(name); if(data.length > 0) { (bool success,) = _implementation().delegatecall(data); require(success); } } } contract __InitializableAdminUpgradeabilityProductProxy__ is __BaseAdminUpgradeabilityProxy__, ProductProxy { function __InitializableAdminUpgradeabilityProductProxy_init__(address admin, address logic, address factory, bytes32 name, bytes memory data) public payable { assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)); assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)); assert(FACTORY_SLOT == bytes32(uint256(keccak256('eip1967.proxy.factory')) - 1)); assert(NAME_SLOT == bytes32(uint256(keccak256('eip1967.proxy.name')) - 1)); address admin_ = _admin(); require(admin_ == address(0) || msg.sender == admin_); _setAdmin(admin); _setImplementation(logic); _setFactory(factory); _setName(name); if(data.length > 0) { (bool success,) = _implementation().delegatecall(data); require(success); } } function _implementation() virtual override(BaseUpgradeabilityProxy, ProductProxy) internal view returns (address impl) { impl = BaseUpgradeabilityProxy._implementation(); if(impl == address(0)) impl = ProductProxy._implementation(); } } contract __AdminUpgradeabilityProductProxy__ is __InitializableAdminUpgradeabilityProductProxy__ { constructor(address admin, address logic, address factory, bytes32 name, bytes memory data) public payable { __InitializableAdminUpgradeabilityProductProxy_init__(admin, logic, factory, name, data); } } /** * @title Initializable * * @dev Helper contract to support initializer functions. To use it, replace * the constructor with a function that has the `initializer` modifier. * WARNING: Unlike constructors, initializer functions must be manually * invoked. This applies both to deploying an Initializable contract, as well * as extending an Initializable contract via inheritance. * WARNING: When used with inheritance, manual care must be taken to not invoke * a parent initializer twice, or ensure that all initializers are idempotent, * because this is not dealt with automatically as with constructors. */ contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private initializing; /** * @dev Modifier to use in the initializer function of a contract. */ modifier initializer() { require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized"); bool isTopLevelCall = !initializing; if (isTopLevelCall) { initializing = true; initialized = true; } _; if (isTopLevelCall) { initializing = false; } } /// @dev Returns true if and only if the function is running in the constructor function isConstructor() private view returns (bool) { // extcodesize checks the size of the code stored in an address, and // address returns the current address. Since the code is still not // deployed when running a constructor, any checks on its code size will // yield zero, making it an effective way to detect if a contract is // under construction or not. address self = address(this); uint256 cs; assembly { cs := extcodesize(self) } return cs == 0; } // Reserved storage space to allow for layout changes in the future. uint256[50] private ______gap; } /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ contract ContextUpgradeSafe is Initializable { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. function __Context_init() internal initializer { __Context_init_unchained(); } function __Context_init_unchained() internal initializer { } function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } uint256[50] private __gap; } /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ contract ReentrancyGuardUpgradeSafe is Initializable { bool private _notEntered; function __ReentrancyGuard_init() internal initializer { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal initializer { // Storing an initial non-zero value makes deployment a bit more // expensive, but in exchange the refund on every call to nonReentrant // will be lower in amount. Since refunds are capped to a percetange of // the total transaction's gas, it is best to keep them low in cases // like this one, to increase the likelihood of the full refund coming // into effect. _notEntered = true; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_notEntered, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _notEntered = false; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _notEntered = true; } uint256[49] private __gap; } /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } // https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol#L687 function sqrt(uint256 x) internal pure returns (uint256) { if (x == 0) return 0; // this block is equivalent to r = uint256(1) << (BitMath.mostSignificantBit(x) / 2); // however that code costs significantly more gas uint256 xx = x; uint256 r = 1; if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; } if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; } if (xx >= 0x100000000) { xx >>= 32; r <<= 16; } if (xx >= 0x10000) { xx >>= 16; r <<= 8; } if (xx >= 0x100) { xx >>= 8; r <<= 4; } if (xx >= 0x10) { xx >>= 4; r <<= 2; } if (xx >= 0x8) { r <<= 1; } r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; // Seven iterations should be enough uint256 r1 = x / r; return (r < r1 ? r : r1); } } /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function sub0(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a - b : 0; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } /** * Utility library of inline functions on addresses * * Source https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-solidity/v2.1.3/contracts/utils/Address.sol * This contract is copied here and renamed from the original to avoid clashes in the compiled artifacts * when the user imports a zos-lib contract (that transitively causes this contract to be compiled and added to the * build/artifacts folder) as well as the vanilla Address implementation from an openzeppelin version. */ library OpenZeppelinUpgradesAddress { /** * Returns whether the target address is a contract * @dev This function will return false if invoked during the constructor of a contract, * as the code is not actually created until after the constructor finishes. * @param account address of the account to check * @return whether the target address is a contract */ function isContract(address account) internal view returns (bool) { uint256 size; // XXX Currently there is no better way to check if there is a contract in an address // than to check the size of the code at that address. // See https://ethereum.stackexchange.com/a/14016/36603 // for more details about how this works. // TODO Check this again before the Serenity release, because all addresses will be // contracts then. // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } } /** * @dev Collection of functions related to the address type */ 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) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @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"); // 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"); } } /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20MinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20UpgradeSafe is ContextUpgradeSafe, IERC20 { using SafeMath for uint256; mapping (address => uint256) internal _balances; mapping (address => mapping (address => uint256)) internal _allowances; uint256 internal _totalSupply; string internal _name; string internal _symbol; uint8 internal _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ function __ERC20_init(string memory name, string memory symbol) internal initializer { __Context_init_unchained(); __ERC20_init_unchained(name, symbol); } function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer { _name = name; _symbol = symbol; _decimals = 18; } /** * @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; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view 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 override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); if(sender != _msgSender() && _allowances[sender][_msgSender()] != uint(-1)) _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. * * This 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); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } uint256[44] private __gap; } /** * @dev Extension of {ERC20} that adds a cap to the supply of tokens. */ contract ERC20CappedUpgradeSafe is ERC20UpgradeSafe { uint256 internal _cap; /** * @dev Sets the value of the `cap`. This value is immutable, it can only be * set once during construction. */ function __ERC20Capped_init(uint256 cap) internal initializer { __Context_init_unchained(); __ERC20Capped_init_unchained(cap); } function __ERC20Capped_init_unchained(uint256 cap) internal initializer { require(cap > 0, "ERC20Capped: cap is 0"); _cap = cap; } /** * @dev Returns the cap on the token's total supply. */ function cap() virtual public view returns (uint256) { return _cap; } /** * @dev See {ERC20-_beforeTokenTransfer}. * * Requirements: * * - minted tokens must not cause the total supply to go over the cap. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override { super._beforeTokenTransfer(from, to, amount); if (from == address(0)) { // When minting tokens require(totalSupply().add(amount) <= _cap, "ERC20Capped: cap exceeded"); } } uint256[49] private __gap; } abstract contract Permit { // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9; function DOMAIN_SEPARATOR() virtual public view returns (bytes32); mapping (address => uint) public nonces; function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external { require(deadline >= block.timestamp, 'permit EXPIRED'); bytes32 digest = keccak256( abi.encodePacked( '\x19\x01', DOMAIN_SEPARATOR(), keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline)) ) ); address recoveredAddress = ecrecover(digest, v, r, s); require(recoveredAddress != address(0) && recoveredAddress == owner, 'permit INVALID_SIGNATURE'); _approve(owner, spender, value); } function _approve(address owner, address spender, uint256 amount) internal virtual; uint256[50] private __gap; } contract PermitERC20UpgradeSafe is Permit, ERC20UpgradeSafe { bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); function DOMAIN_SEPARATOR() virtual override public view returns (bytes32) { return keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name())), _chainId(), address(this))); } function _chainId() internal pure returns (uint id) { assembly { id := chainid() } } function _approve(address owner, address spender, uint256 amount) virtual override(Permit, ERC20UpgradeSafe) internal { return ERC20UpgradeSafe._approve(owner, spender, amount); } } /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. // A Solidity high level call has three parts: // 1. The target address is checked to verify it contains contract code // 2. The call itself is made, and success asserted // 3. The return value is decoded, which in turn checks the size of the returned data. // solhint-disable-next-line max-line-length require(address(token).isContract(), "SafeERC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract Governable is Initializable { // bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1) bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; address public governor; event GovernorshipTransferred(address indexed previousGovernor, address indexed newGovernor); /** * @dev Contract initializer. * called once by the factory at time of deployment */ function __Governable_init_unchained(address governor_) virtual public initializer { governor = governor_; emit GovernorshipTransferred(address(0), governor); } function _admin() internal view returns (address adm) { bytes32 slot = ADMIN_SLOT; assembly { adm := sload(slot) } } modifier governance() { require(msg.sender == governor || msg.sender == _admin()); _; } /** * @dev Allows the current governor to relinquish control of the contract. * @notice Renouncing to governorship will leave the contract without an governor. * It will not be possible to call the functions with the `governance` * modifier anymore. */ function renounceGovernorship() public governance { emit GovernorshipTransferred(governor, address(0)); governor = address(0); } /** * @dev Allows the current governor to transfer control of the contract to a newGovernor. * @param newGovernor The address to transfer governorship to. */ function transferGovernorship(address newGovernor) public governance { _transferGovernorship(newGovernor); } /** * @dev Transfers control of the contract to a newGovernor. * @param newGovernor The address to transfer governorship to. */ function _transferGovernorship(address newGovernor) internal { require(newGovernor != address(0)); emit GovernorshipTransferred(governor, newGovernor); governor = newGovernor; } } contract Configurable is Governable { mapping (bytes32 => uint) internal config; function getConfig(bytes32 key) public view returns (uint) { return config[key]; } function getConfigI(bytes32 key, uint index) public view returns (uint) { return config[bytes32(uint(key) ^ index)]; } function getConfigA(bytes32 key, address addr) public view returns (uint) { return config[bytes32(uint(key) ^ uint(addr))]; } function _setConfig(bytes32 key, uint value) internal { if(config[key] != value) config[key] = value; } function _setConfig(bytes32 key, uint index, uint value) internal { _setConfig(bytes32(uint(key) ^ index), value); } function _setConfig(bytes32 key, address addr, uint value) internal { _setConfig(bytes32(uint(key) ^ uint(addr)), value); } function setConfig(bytes32 key, uint value) external governance { _setConfig(key, value); } function setConfigI(bytes32 key, uint index, uint value) external governance { _setConfig(bytes32(uint(key) ^ index), value); } function setConfigA(bytes32 key, address addr, uint value) public governance { _setConfig(bytes32(uint(key) ^ uint(addr)), value); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"mine_","type":"address"},{"internalType":"address","name":"eco_","type":"address"},{"internalType":"address","name":"team_","type":"address"},{"internalType":"address","name":"contribution_","type":"address"},{"internalType":"address","name":"liqudity_","type":"address"},{"internalType":"address","name":"public_","type":"address"},{"internalType":"address","name":"airdrop_","type":"address"}],"name":"__ASAP_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"mine_","type":"address"},{"internalType":"address","name":"eco_","type":"address"},{"internalType":"address","name":"team_","type":"address"},{"internalType":"address","name":"contribution_","type":"address"},{"internalType":"address","name":"liqudity_","type":"address"},{"internalType":"address","name":"public_","type":"address"},{"internalType":"address","name":"airdrop_","type":"address"}],"name":"__ASAP_init_unchained","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
124:1070:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47106:83:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49212:169;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;48181:100::-;;;:::i;:::-;;;;;;;:::i;58632:122::-;;;:::i;49855:410::-;;;;;;:::i;:::-;;:::i;57524:108::-;;;:::i;48033:83::-;;;:::i;:::-;;;;;;;:::i;58767:192::-;;;:::i;50674:218::-;;;;;;:::i;:::-;;:::i;539:652:0:-;;;;;;:::i;:::-;;:::i;:::-;;48344:119:1;;;;;;:::i;:::-;;:::i;57713:39::-;;;;;;:::i;:::-;;:::i;47308:87::-;;;:::i;51395:269::-;;;;;;:::i;:::-;;:::i;48676:175::-;;;;;;:::i;:::-;;:::i;168:365:0:-;;;;;;:::i;:::-;;:::i;57761:668:1:-;;;;;;:::i;:::-;;:::i;48914:151::-;;;;;;:::i;:::-;;:::i;47106:83::-;47176:5;47169:12;;;;;;;;-1:-1:-1;;47169:12:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47143:13;;47169:12;;47176:5;;47169:12;;47176:5;47169:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47106:83;:::o;49212:169::-;49295:4;49312:39;49321:12;:10;:12::i;:::-;49335:7;49344:6;49312:8;:39::i;:::-;-1:-1:-1;49369:4:1;49212:169;;;;;:::o;48181:100::-;48261:12;;48181:100;:::o;58632:122::-;58674:80;58632:122;:::o;49855:410::-;49961:4;49978:36;49988:6;49996:9;50007:6;49978:9;:36::i;:::-;50038:12;:10;:12::i;:::-;-1:-1:-1;;;;;50028:22:1;:6;-1:-1:-1;;;;;50028:22:1;;;:71;;;;-1:-1:-1;;;;;;50054:19:1;;;;;;:11;:19;;;;;-1:-1:-1;;50096:2:1;50074:12;:10;:12::i;:::-;-1:-1:-1;;;;;50054:33:1;-1:-1:-1;;;;;50054:33:1;;;;;;;;;;;;;:45;;50028:71;50025:210;;;50114:121;50123:6;50131:12;:10;:12::i;:::-;50145:89;50183:6;50145:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50145:19:1;;;;;;:11;:19;;;;;;50165:12;:10;:12::i;:::-;-1:-1:-1;;;;;50145:33:1;;;;;;;;;;;;-1:-1:-1;50145:33:1;;;:89;:37;:89::i;:::-;50114:8;:121::i;:::-;-1:-1:-1;50253:4:1;49855:410;;;;;:::o;57524:108::-;57566:66;57524:108;:::o;48033:83::-;48099:9;;;;48033:83;:::o;58767:192::-;58833:7;58674:80;58914:6;:4;:6::i;:::-;58898:24;;;;;;58924:10;:8;:10::i;:::-;58944:4;58870:80;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;58860:91;;;;;;58853:98;;58767:192;:::o;50674:218::-;50762:4;50779:83;50788:12;:10;:12::i;:::-;50802:7;50811:50;50850:10;50811:11;:25;50823:12;:10;:12::i;:::-;-1:-1:-1;;;;;50811:25:1;;;;;;;;;;;;;;;;;-1:-1:-1;50811:25:1;;;:34;;;;;;;;;;;:38;:50::i;539:652:0:-;25661:12:1;;;;;;;;:31;;;25677:15;:13;:15::i;:::-;25661:47;;;-1:-1:-1;25697:11:1;;;;25696:12;25661:47;25653:106;;;;-1:-1:-1;;;25653:106:1;;;;;;;:::i;:::-;;;;;;;;;25791:12;;;;;;;25790:13;25810:83;;;;25839:12;:19;;-1:-1:-1;;;;25839:19:1;;;;;25867:18;25854:4;25867:18;;;25810:83;715:63:0::1;721:5;766:10;:8;:10::i;:::-;758:19;;752:2;:25;739:10;:38;715:5;:63::i;:::-;783;789:4;834:10;:8;:10::i;:::-;826:19;;820:2;:25;807:10;:38;783:5;:63::i;:::-;851;857:5;902:10;:8;:10::i;851:63::-;919;925:13;970:10;:8;:10::i;:::-;962:19;;956:2;:25;943:10;:38;919:5;:63::i;:::-;987;993:9;1038:10;:8;:10::i;:::-;1030:19;;1024:2;:25;1012:9;:37;987:5;:63::i;:::-;1055;1061:7;1106:10;:8;:10::i;:::-;1098:19;;1092:2;:25;1080:9;:37;1055:5;:63::i;:::-;1123;1129:8;1174:10;:8;:10::i;1123:63::-;25915:14:1::0;25911:57;;;25940:12;:20;;-1:-1:-1;;25940:20:1;;;25911:57;539:652:0;;;;;;;;:::o;48344:119:1:-;-1:-1:-1;;;;;48437:18:1;48410:7;48437:18;;;:9;:18;;;;;;;48344:119::o;57713:39::-;;;;;;;;;;;;;;:::o;47308:87::-;47380:7;47373:14;;;;;;;;-1:-1:-1;;47373:14:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47347:13;;47373:14;;47380:7;;47373:14;;47380:7;47373:14;;;;;;;;;;;;;;;;;;;;;;;;51395:269;51488:4;51505:129;51514:12;:10;:12::i;:::-;51528:7;51537:96;51576:15;51537:96;;;;;;;;;;;;;;;;;:11;:25;51549:12;:10;:12::i;:::-;-1:-1:-1;;;;;51537:25:1;;;;;;;;;;;;;;;;;-1:-1:-1;51537:25:1;;;:34;;;;;;;;;;;:96;:38;:96::i;48676:175::-;48762:4;48779:42;48789:12;:10;:12::i;:::-;48803:9;48814:6;48779:9;:42::i;168:365:0:-;25661:12:1;;;;;;;;:31;;;25677:15;:13;:15::i;:::-;25661:47;;;-1:-1:-1;25697:11:1;;;;25696:12;25661:47;25653:106;;;;-1:-1:-1;;;25653:106:1;;;;;;;:::i;:::-;25791:12;;;;;;;25790:13;25810:83;;;;25839:12;:19;;-1:-1:-1;;;;25839:19:1;;;;;25867:18;25854:4;25867:18;;;25810:83;342:26:0::1;:24;:26::i;:::-;373:64;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;-1:-1:-1::0;;;373:64:0::1;;::::0;:22:::1;:64::i;:::-;442:86;464:5;471:4;477:5;484:13;499:9;510:7;519:8;442:21;:86::i;57761:668:1:-:0;57907:15;57895:8;:27;;57887:54;;;;-1:-1:-1;;;57887:54:1;;;;;;;:::i;:::-;57952:14;58057:18;:16;:18::i;:::-;-1:-1:-1;;;;;58155:13:1;;58115:15;58155:13;;;;;;;;;;;;:15;;;;;;;;58104:77;;;;57566:66;;58132:5;;58139:7;;58148:5;;58155:15;;58172:8;;58104:77;;:::i;:::-;;;;;;;;;;;;;58094:88;;;;;;57993:204;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57969:239;;;;;;57952:256;;58219:24;58246:26;58256:6;58264:1;58267;58270;58246:26;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;58246:26:1;;-1:-1:-1;;58246:26:1;;;-1:-1:-1;;;;;;;58291:30:1;;;;;;:59;;;58345:5;-1:-1:-1;;;;;58325:25:1;:16;-1:-1:-1;;;;;58325:25:1;;58291:59;58283:96;;;;-1:-1:-1;;;58283:96:1;;;;;;;:::i;:::-;58390:31;58399:5;58406:7;58415:5;58390:8;:31::i;:::-;57761:668;;;;;;;;;:::o;48914:151::-;-1:-1:-1;;;;;49030:18:1;;;49003:7;49030:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;48914:151::o;27586:106::-;27674:10;27586:106;:::o;59081:193::-;59217:49;59243:5;59250:7;59259:6;59217:25;:49::i;:::-;59081:193;;;:::o;52154:539::-;-1:-1:-1;;;;;52260:20:1;;52252:70;;;;-1:-1:-1;;;52252:70:1;;;;;;;:::i;:::-;-1:-1:-1;;;;;52341:23:1;;52333:71;;;;-1:-1:-1;;;52333:71:1;;;;;;;:::i;:::-;52417:47;52438:6;52446:9;52457:6;52417:20;:47::i;:::-;52497:71;52519:6;52497:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52497:17:1;;;;;;:9;:17;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;52477:17:1;;;;;;;:9;:17;;;;;;:91;;;;52602:20;;;;;;;:32;;52627:6;52602:24;:32::i;:::-;-1:-1:-1;;;;;52579:20:1;;;;;;;:9;:20;;;;;;;:55;;;;52650:35;;;;;;;;;;52678:6;;52650:35;:::i;:::-;;;;;;;;52154:539;;;:::o;34191:192::-;34277:7;34313:12;34305:6;;;;34297:29;;;;-1:-1:-1;;;34297:29:1;;;;;;;;:::i;:::-;-1:-1:-1;;;34349:5:1;;;34191:192::o;58971:98::-;59051:9;;59043:19::o;33304:181::-;33362:7;33394:5;;;33418:6;;;;33410:46;;;;-1:-1:-1;;;33410:46:1;;;;;;;:::i;:::-;33476:1;33304:181;-1:-1:-1;;;33304:181:1:o;26062:508::-;26479:4;26525:17;26557:7;26062:508;:::o;52974:378::-;-1:-1:-1;;;;;53058:21:1;;53050:65;;;;-1:-1:-1;;;53050:65:1;;;;;;;:::i;:::-;53128:49;53157:1;53161:7;53170:6;53128:20;:49::i;:::-;53205:12;;:24;;53222:6;53205:16;:24::i;:::-;53190:12;:39;-1:-1:-1;;;;;53261:18:1;;;;;;:9;:18;;;;;;:30;;53284:6;53261:22;:30::i;:::-;-1:-1:-1;;;;;53240:18:1;;;;;;:9;:18;;;;;;:51;;;;53307:37;;53240:18;;;53307:37;;;;53337:6;;53307:37;:::i;:::-;;;;;;;;52974:378;;:::o;27507:69::-;25661:12;;;;;;;;:31;;;25677:15;:13;:15::i;:::-;25661:47;;;-1:-1:-1;25697:11:1;;;;25696:12;25661:47;25653:106;;;;-1:-1:-1;;;25653:106:1;;;;;;;:::i;:::-;25791:12;;;;;;;25790:13;25810:83;;;;25839:12;:19;;-1:-1:-1;;;;25839:19:1;;;;;25867:18;25854:4;25867:18;;;25810:83;25915:14;25911:57;;;25940:12;:20;;-1:-1:-1;;25940:20:1;;;25911:57;27507:69;:::o;46850:184::-;25661:12;;;;;;;;:31;;;25677:15;:13;:15::i;:::-;25661:47;;;-1:-1:-1;25697:11:1;;;;25696:12;25661:47;25653:106;;;;-1:-1:-1;;;25653:106:1;;;;;;;:::i;:::-;25791:12;;;;;;;25790:13;25810:83;;;;25839:12;:19;;-1:-1:-1;;;;25839:19:1;;;;;25867:18;25854:4;25867:18;;;25810:83;46960:12;;::::1;::::0;:5:::1;::::0;:12:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;46983:16:1;;::::1;::::0;:7:::1;::::0;:16:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;47010:9:1::1;:14:::0;;-1:-1:-1;;47010:14:1::1;47022:2;47010:14;::::0;;25911:57;;;;25940:12;:20;;-1:-1:-1;;25940:20:1;;;46850:184;;;:::o;54542:346::-;-1:-1:-1;;;;;54644:19:1;;54636:68;;;;-1:-1:-1;;;54636:68:1;;;;;;;:::i;:::-;-1:-1:-1;;;;;54723:21:1;;54715:68;;;;-1:-1:-1;;;54715:68:1;;;;;;;:::i;:::-;-1:-1:-1;;;;;54796:18:1;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;54848:32;;;;;54826:6;;54848:32;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;5:130;72:20;;-1:-1;;;;;17173:54;;17928:35;;17918:2;;17977:1;;17967:12;549:241;;653:2;641:9;632:7;628:23;624:32;621:2;;;-1:-1;;659:12;621:2;721:53;766:7;742:22;721:53;:::i;797:366::-;;;918:2;906:9;897:7;893:23;889:32;886:2;;;-1:-1;;924:12;886:2;986:53;1031:7;1007:22;986:53;:::i;:::-;976:63;;1094:53;1139:7;1076:2;1119:9;1115:22;1094:53;:::i;:::-;1084:63;;880:283;;;;;:::o;1170:995::-;;;;;;;;1376:3;1364:9;1355:7;1351:23;1347:33;1344:2;;;-1:-1;;1383:12;1344:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;1435:63;-1:-1;1535:2;1574:22;;72:20;97:33;72:20;97:33;:::i;:::-;1543:63;-1:-1;1643:2;1682:22;;72:20;97:33;72:20;97:33;:::i;:::-;1651:63;-1:-1;1751:2;1790:22;;72:20;97:33;72:20;97:33;:::i;:::-;1759:63;-1:-1;1859:3;1899:22;;72:20;97:33;72:20;97:33;:::i;:::-;1868:63;-1:-1;1968:3;2008:22;;72:20;97:33;72:20;97:33;:::i;:::-;1977:63;-1:-1;2077:3;2117:22;;72:20;97:33;72:20;97:33;:::i;:::-;2086:63;;;;1338:827;;;;;;;;;;:::o;2172:491::-;;;;2310:2;2298:9;2289:7;2285:23;2281:32;2278:2;;;-1:-1;;2316:12;2278:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2368:63;-1:-1;2468:2;2507:22;;72:20;97:33;72:20;97:33;:::i;:::-;2272:391;;2476:63;;-1:-1;;;2576:2;2615:22;;;;346:20;;2272:391::o;2670:991::-;;;;;;;;2874:3;2862:9;2853:7;2849:23;2845:33;2842:2;;;-1:-1;;2881:12;2842:2;2943:53;2988:7;2964:22;2943:53;:::i;:::-;2933:63;;3051:53;3096:7;3033:2;3076:9;3072:22;3051:53;:::i;:::-;3041:63;;3141:2;3184:9;3180:22;346:20;3149:63;;3249:2;3292:9;3288:22;346:20;3257:63;;3357:3;3399:9;3395:22;481:20;17389:4;18324:5;17378:16;18301:5;18298:33;18288:2;;-1:-1;;18335:12;18288:2;2836:825;;;;-1:-1;2836:825;;;;3366:61;3464:3;3504:22;;209:20;;-1:-1;3573:3;3613:22;;;209:20;;2836:825;-1:-1;;2836:825::o;3668:366::-;;;3789:2;3777:9;3768:7;3764:23;3760:32;3757:2;;;-1:-1;;3795:12;3757:2;3857:53;3902:7;3878:22;3857:53;:::i;:::-;3847:63;3947:2;3986:22;;;;346:20;;-1:-1;;;3751:283::o;8796:659::-;-1:-1;;;5942:87;;5927:1;6048:11;;4343:37;;;;9307:12;;;4343:37;9418:12;;;9041:414::o;9462:210::-;17006:13;;16999:21;4226:34;;9583:2;9568:18;;9554:118::o;9679:222::-;4343:37;;;9806:2;9791:18;;9777:124::o;9908:780::-;4343:37;;;-1:-1;;;;;17173:54;;;10340:2;10325:18;;4112:37;17173:54;;;;10423:2;10408:18;;4112:37;10506:2;10491:18;;4343:37;10589:3;10574:19;;4343:37;;;;17184:42;10658:19;;4343:37;10175:3;10160:19;;10146:542::o;10695:556::-;4343:37;;;11071:2;11056:18;;4343:37;;;;11154:2;11139:18;;4343:37;-1:-1;;;;;17173:54;11237:2;11222:18;;4112:37;10906:3;10891:19;;10877:374::o;11258:548::-;4343:37;;;17389:4;17378:16;;;;11626:2;11611:18;;8749:35;11709:2;11694:18;;4343:37;11792:2;11777:18;;4343:37;11465:3;11450:19;;11436:370::o;11813:310::-;;11960:2;;11981:17;11974:47;4696:5;16475:12;16632:6;11960:2;11949:9;11945:18;16620:19;-1:-1;17479:101;17493:6;17490:1;17487:13;17479:101;;;17560:11;;;;;17554:18;17541:11;;;16660:14;17541:11;17534:39;17508:10;;17479:101;;;17595:6;17592:1;17589:13;17586:2;;;-1:-1;16660:14;17651:6;11949:9;17642:16;;17635:27;17586:2;-1:-1;17848:7;17832:14;-1:-1;;17828:28;4854:39;;;;16660:14;4854:39;;11931:192;-1:-1;;;11931:192::o;12130:416::-;12330:2;12344:47;;;5130:2;12315:18;;;16620:19;5166:34;16660:14;;;5146:55;-1:-1;;;5221:12;;;5214:27;5260:12;;;12301:245::o;12553:416::-;12753:2;12767:47;;;5511:2;12738:18;;;16620:19;5547:34;16660:14;;;5527:55;-1:-1;;;5602:12;;;5595:26;5640:12;;;12724:245::o;12976:416::-;13176:2;13190:47;;;6298:2;13161:18;;;16620:19;6334:29;16660:14;;;6314:50;6383:12;;;13147:245::o;13399:416::-;13599:2;13613:47;;;6634:2;13584:18;;;16620:19;6670:26;16660:14;;;6650:47;6716:12;;;13570:245::o;13822:416::-;14022:2;14036:47;;;6967:2;14007:18;;;16620:19;-1:-1;;;16660:14;;;6983:37;7039:12;;;13993:245::o;14245:416::-;14445:2;14459:47;;;7290:2;14430:18;;;16620:19;7326:34;16660:14;;;7306:55;-1:-1;;;7381:12;;;7374:38;7431:12;;;14416:245::o;14668:416::-;14868:2;14882:47;;;7682:2;14853:18;;;16620:19;7718:34;16660:14;;;7698:55;-1:-1;;;7773:12;;;7766:29;7814:12;;;14839:245::o;15091:416::-;15291:2;15305:47;;;8065:2;15276:18;;;16620:19;8101:34;16660:14;;;8081:55;-1:-1;;;8156:12;;;8149:28;8196:12;;;15262:245::o;15514:416::-;15714:2;15728:47;;;8447:2;15699:18;;;16620:19;8483:33;16660:14;;;8463:54;8536:12;;;15685:245::o;16166:214::-;17389:4;17378:16;;;;8749:35;;16289:2;16274:18;;16260:120::o;17869:117::-;-1:-1;;;;;17173:54;;17928:35;;17918:2;;17977:1;;17967:12
Swarm Source
ipfs://0f8b3f9d8dea043667e0c9ea1ec8f65ac5fb58d0294231b23cf9028198e30cec
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.