More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 532 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Beneficiary With... | 8815951 | 1825 days ago | IN | 0 ETH | 0.00004175 | ||||
Beneficiary With... | 8815937 | 1825 days ago | IN | 0 ETH | 0.00063662 | ||||
Beneficiary With... | 8815916 | 1825 days ago | IN | 0 ETH | 0.00004175 | ||||
Beneficiary With... | 8815913 | 1825 days ago | IN | 0 ETH | 0.00063662 | ||||
Transfer | 8811472 | 1826 days ago | IN | 0.135 ETH | 0.000021 | ||||
Transfer | 8805790 | 1827 days ago | IN | 0.455 ETH | 0.00011342 | ||||
Transfer | 8805012 | 1827 days ago | IN | 1.9887618 ETH | 0.00015879 | ||||
Transfer | 8804591 | 1827 days ago | IN | 1.75744787 ETH | 0.00255213 | ||||
Transfer | 8804567 | 1827 days ago | IN | 3 ETH | 0.00187713 | ||||
Transfer | 8804557 | 1827 days ago | IN | 1 ETH | 0.00112627 | ||||
Transfer | 8804454 | 1827 days ago | IN | 1.043625 ETH | 0.00255213 | ||||
Transfer | 8804373 | 1827 days ago | IN | 2 ETH | 0.00033371 | ||||
Transfer | 8804271 | 1827 days ago | IN | 1.354 ETH | 0.00113428 | ||||
Transfer | 8803811 | 1827 days ago | IN | 12.41 ETH | 0.00166856 | ||||
Transfer | 8803581 | 1827 days ago | IN | 0.89 ETH | 0.00250284 | ||||
Transfer | 8802753 | 1827 days ago | IN | 2.35 ETH | 0.00342054 | ||||
Transfer | 8801372 | 1828 days ago | IN | 0.59238642 ETH | 0.00070079 | ||||
Transfer | 8801364 | 1828 days ago | IN | 0.59343761 ETH | 0.000168 | ||||
Transfer | 8798611 | 1828 days ago | IN | 2.01 ETH | 0.00342054 | ||||
Transfer | 8797782 | 1828 days ago | IN | 1.98252888 ETH | 0.00182308 | ||||
Transfer | 8796631 | 1828 days ago | IN | 1.497 ETH | 0.00465054 | ||||
Transfer | 8796212 | 1828 days ago | IN | 3.11 ETH | 0.00342054 | ||||
Transfer | 8795729 | 1828 days ago | IN | 1 ETH | 0.00068056 | ||||
Transfer | 8795701 | 1828 days ago | IN | 1 ETH | 0.000126 | ||||
Transfer | 8791512 | 1829 days ago | IN | 2 ETH | 0.00022685 |
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
8805790 | 1827 days ago | 0.455 ETH | ||||
8805012 | 1827 days ago | 1.9887618 ETH | ||||
8804591 | 1827 days ago | 1.75744787 ETH | ||||
8804567 | 1827 days ago | 3 ETH | ||||
8804557 | 1827 days ago | 1 ETH | ||||
8804454 | 1827 days ago | 1.043625 ETH | ||||
8804373 | 1827 days ago | 2 ETH | ||||
8804271 | 1827 days ago | 1.354 ETH | ||||
8803811 | 1827 days ago | 12.41 ETH | ||||
8803581 | 1827 days ago | 0.89 ETH | ||||
8802753 | 1827 days ago | 2.35 ETH | ||||
8801372 | 1828 days ago | 0.59238642 ETH | ||||
8798611 | 1828 days ago | 2.01 ETH | ||||
8797782 | 1828 days ago | 1.98252888 ETH | ||||
8796631 | 1828 days ago | 1.497 ETH | ||||
8796212 | 1828 days ago | 3.11 ETH | ||||
8795729 | 1828 days ago | 1 ETH | ||||
8791512 | 1829 days ago | 2 ETH | ||||
8791150 | 1829 days ago | 2.07534945 ETH | ||||
8791079 | 1829 days ago | 1.03 ETH | ||||
8790936 | 1829 days ago | 1.682 ETH | ||||
8790656 | 1829 days ago | 0.82854437 ETH | ||||
8790509 | 1829 days ago | 0.34 ETH | ||||
8789795 | 1829 days ago | 3 ETH | ||||
8788598 | 1830 days ago | 1.92 ETH |
Loading...
Loading
Contract Name:
Moon_Token_Crowdsale
Compiler Version
v0.5.8+commit.23d335f2
Optimization Enabled:
No with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2019-05-25 */ /* Moon Token for MoonTrader Platform and projects More information at https://moontrader.io/ MoonTrader is a successor of the MoonBot project, https://moon-bot.com/en/ Mail us to: [email protected] Join the Telegram channel https://t.me/moontrader_news_en, Visit BTT forum thread https://bitcointalk.org/index.php?topic=5143969 for more information. */ // File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol pragma solidity ^0.5.2; /** * @title ERC20 interface * @dev see https://eips.ethereum.org/EIPS/eip-20 */ interface IERC20 { function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } // File: openzeppelin-solidity/contracts/math/SafeMath.sol pragma solidity ^0.5.2; /** * @title SafeMath * @dev Unsigned math operations with safety checks that revert on error */ library SafeMath { /** * @dev Multiplies two unsigned integers, reverts on 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-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } /** * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend). */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } /** * @dev Adds two unsigned integers, reverts on overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } /** * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo), * reverts when dividing by zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol pragma solidity ^0.5.2; /** * @title Standard ERC20 token * * @dev Implementation of the basic standard token. * https://eips.ethereum.org/EIPS/eip-20 * Originally based on code by FirstBlood: * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol * * This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for * all accounts just by listening to said events. Note that this isn't required by the specification, and other * compliant implementations may not do it. */ contract ERC20 is IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowed; uint256 private _totalSupply; /** * @dev Total number of tokens in existence */ function totalSupply() public view returns (uint256) { return _totalSupply; } /** * @dev Gets the balance of the specified address. * @param owner The address to query the balance of. * @return A uint256 representing the amount owned by the passed address. */ function balanceOf(address owner) public view returns (uint256) { return _balances[owner]; } /** * @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 Transfer token to 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) { _transfer(msg.sender, 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) { _approve(msg.sender, spender, value); return true; } /** * @dev Transfer tokens from one address to another. * Note that while this function emits an Approval event, this is not required as per the specification, * and other compliant implementations may not emit the event. * @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) { _transfer(from, to, value); _approve(from, msg.sender, _allowed[from][msg.sender].sub(value)); return true; } /** * @dev Increase the amount of tokens that an owner allowed to a spender. * approve should be called when _allowed[msg.sender][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 * Emits an Approval event. * @param spender The address which will spend the funds. * @param addedValue The amount of tokens to increase the allowance by. */ function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue)); return true; } /** * @dev Decrease the amount of tokens that an owner allowed to a spender. * approve should be called when _allowed[msg.sender][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 * Emits an Approval event. * @param spender The address which will spend the funds. * @param subtractedValue The amount of tokens to decrease the allowance by. */ function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue)); return true; } /** * @dev Transfer token for a specified addresses * @param from The address to transfer from. * @param to The address to transfer to. * @param value The amount to be transferred. */ function _transfer(address from, address to, uint256 value) internal { require(to != address(0)); _balances[from] = _balances[from].sub(value); _balances[to] = _balances[to].add(value); emit Transfer(from, to, value); } /** * @dev Internal function that mints an amount of the token and assigns it to * an account. This encapsulates the modification of balances such that the * proper events are emitted. * @param account The account that will receive the created tokens. * @param value The amount that will be created. */ function _mint(address account, uint256 value) internal { require(account != address(0)); _totalSupply = _totalSupply.add(value); _balances[account] = _balances[account].add(value); emit Transfer(address(0), account, value); } /** * @dev Internal function that burns an amount of the token of a given * account. * @param account The account whose tokens will be burnt. * @param value The amount that will be burnt. */ function _burn(address account, uint256 value) internal { require(account != address(0)); _totalSupply = _totalSupply.sub(value); _balances[account] = _balances[account].sub(value); emit Transfer(account, address(0), value); } /** * @dev Approve an address to spend another addresses' tokens. * @param owner The address that owns the tokens. * @param spender The address that will spend the tokens. * @param value The number of tokens that can be spent. */ function _approve(address owner, address spender, uint256 value) internal { require(spender != address(0)); require(owner != address(0)); _allowed[owner][spender] = value; emit Approval(owner, spender, value); } /** * @dev Internal function that burns an amount of the token of a given * account, deducting from the sender's allowance for said account. Uses the * internal burn function. * Emits an Approval event (reflecting the reduced allowance). * @param account The account whose tokens will be burnt. * @param value The amount that will be burnt. */ function _burnFrom(address account, uint256 value) internal { _burn(account, value); _approve(account, msg.sender, _allowed[account][msg.sender].sub(value)); } } // File: openzeppelin-solidity/contracts/access/Roles.sol pragma solidity ^0.5.2; /** * @title Roles * @dev Library for managing addresses assigned to a Role. */ library Roles { struct Role { mapping (address => bool) bearer; } /** * @dev give an account access to this role */ function add(Role storage role, address account) internal { require(account != address(0)); require(!has(role, account)); role.bearer[account] = true; } /** * @dev remove an account's access to this role */ function remove(Role storage role, address account) internal { require(account != address(0)); require(has(role, account)); role.bearer[account] = false; } /** * @dev check if an account has this role * @return bool */ function has(Role storage role, address account) internal view returns (bool) { require(account != address(0)); return role.bearer[account]; } } // File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol pragma solidity ^0.5.2; contract MinterRole { using Roles for Roles.Role; event MinterAdded(address indexed account); event MinterRemoved(address indexed account); Roles.Role private _minters; constructor () internal { _addMinter(msg.sender); } modifier onlyMinter() { require(isMinter(msg.sender)); _; } function isMinter(address account) public view returns (bool) { return _minters.has(account); } function addMinter(address account) public onlyMinter { _addMinter(account); } function renounceMinter() public { _removeMinter(msg.sender); } function _addMinter(address account) internal { _minters.add(account); emit MinterAdded(account); } function _removeMinter(address account) internal { _minters.remove(account); emit MinterRemoved(account); } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol pragma solidity ^0.5.2; /** * @title ERC20Mintable * @dev ERC20 minting logic */ contract ERC20Mintable is ERC20, MinterRole { /** * @dev Function to mint tokens * @param to The address that will receive the minted tokens. * @param value The amount of tokens to mint. * @return A boolean that indicates if the operation was successful. */ function mint(address to, uint256 value) public onlyMinter returns (bool) { _mint(to, value); return true; } } // File: openzeppelin-solidity/contracts/utils/Address.sol pragma solidity ^0.5.2; /** * Utility library of inline functions on addresses */ library Address { /** * 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; } } // File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol pragma solidity ^0.5.2; /** * @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' require((value == 0) || (token.allowance(address(this), spender) == 0)); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @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 equal true). * @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. require(address(token).isContract()); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool))); } } } // File: openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol pragma solidity ^0.5.2; /** * @title Helps contracts guard against reentrancy attacks. * @author Remco Bloemen <remco@2π.com>, Eenae <[email protected]> * @dev If you mark a function `nonReentrant`, you should also * mark it `external`. */ contract ReentrancyGuard { /// @dev counter to allow mutex lock with only one SSTORE operation uint256 private _guardCounter; constructor () internal { // The counter starts at one to prevent changing it from zero to a non-zero // value, which is a more expensive operation. _guardCounter = 1; } /** * @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() { _guardCounter += 1; uint256 localCounter = _guardCounter; _; require(localCounter == _guardCounter); } } // File: contracts/Crowdsale/Core/Crowdsale.sol pragma solidity ^0.5.2; /** * @title Crowdsale * @dev Crowdsale is a base contract for managing a token crowdsale, * allowing investors to purchase tokens with ether. This contract implements * such functionality in its most fundamental form and can be extended to provide additional * functionality and/or custom behavior. * The external interface represents the basic interface for purchasing tokens, and conforms * the base architecture for crowdsales. It is *not* intended to be modified / overridden. * The internal interface conforms the extensible and modifiable surface of crowdsales. Override * the methods to add functionality. Consider using 'super' where appropriate to concatenate * behavior. */ contract Crowdsale is ReentrancyGuard { using SafeMath for uint256; using SafeERC20 for IERC20; // The token being sold IERC20 private _token; // Address where funds are collected address payable private _wallet; // How many token units a buyer gets per wei. // The rate is the conversion between wei and the smallest and indivisible token unit. // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK // 1 wei will give you 1 unit, or 0.001 TOK. uint256 private _rate; // Amount of wei raised uint256 private _weiRaised; // Hardcap in tokens uint256 private _supply; // Amount of sold tokens uint256 private _sold; /** * Event for token purchase logging * @param purchaser who paid for the tokens * @param beneficiary who got the tokens * @param value weis paid for purchase * @param amount amount of tokens purchased */ event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); /** * Event for conversion rate changes logging * @param rate New rate */ event RateUpdated(uint256 indexed rate); /** * Events for crowdsale state tracking */ event CrowdsalePaused(); event CrowdsaleUnpaused(); /** * @param rate Number of token units a buyer gets per wei * @dev The rate is the conversion between wei and the smallest and indivisible * token unit. So, if you are using a rate of 1 with a ERC20Detailed token * with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK. * @param wallet Address where collected funds will be forwarded to * @param token Address of the token being sold */ constructor (uint256 rate, uint256 supply, address payable wallet, IERC20 token) public { require(rate > 0); require(wallet != address(0)); require(address(token) != address(0)); _rate = rate; _supply = supply; _wallet = wallet; _token = token; } /** * @dev fallback function ***DO NOT OVERRIDE*** * Note that other contracts will transfer funds with a base gas stipend * of 2300, which is not enough to call buyTokens. Consider calling * buyTokens directly when purchasing tokens from a contract. */ function() external payable { buyTokens(msg.sender); } /** * @return the token being sold. */ function token() public view returns (IERC20) { return _token; } /** * @return amount of supplied tokens. */ function supply() internal view returns (uint256) { return _supply; } /** * @return amount of sold tokens. */ function sold() public view returns (uint256) { return _sold; } /** * @dev Increase amount of sold tokens by tokenAmount. * @param tokenAmount Amount of last-purchased tokens */ function _addSold(uint256 tokenAmount) internal { _sold = _sold.add(tokenAmount); } /** * @return the address where funds are collected. */ function wallet() public view returns (address payable) { return _wallet; } /** * @return the number of token units a buyer gets per wei. */ function rate() public view returns (uint256) { return _rate; } /** * @return the amount of wei raised. */ function weiRaised() public view returns (uint256) { return _weiRaised; } /** * @dev low level token purchase ***DO NOT OVERRIDE*** * This function has a non-reentrancy guard, so it shouldn't be called by * another `nonReentrant` function. * @param beneficiary Recipient of the token purchase */ function buyTokens(address beneficiary) public nonReentrant payable { uint256 weiAmount = msg.value; _preValidatePurchase(beneficiary, weiAmount); uint256 surplus = _countSurplus(weiAmount); weiAmount -= surplus; // calculate token amount to be created uint256 tokens = _getTokenAmount(weiAmount); // update state _weiRaised = _weiRaised.add(weiAmount); _processPurchase(beneficiary, tokens); emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens); _updatePurchasingState(beneficiary, weiAmount); _forwardFunds(weiAmount); _returnSurplus(surplus); _postValidatePurchase(beneficiary, weiAmount); } /** * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met. * Use `super` in contracts that inherit from Crowdsale to extend their validations. * Example from CappedCrowdsale.sol's _preValidatePurchase method: * super._preValidatePurchase(beneficiary, weiAmount); * require(weiRaised().add(weiAmount) <= cap); * @param beneficiary Address performing the token purchase * @param weiAmount Value in wei involved in the purchase */ function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view { require(beneficiary != address(0)); require(weiAmount != 0); require(rate() > 0); require(_supply >= _sold + _getTokenAmount(weiAmount)); //todo } /** * @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid * conditions are not met. * @param beneficiary Address performing the token purchase * @param weiAmount Value in wei involved in the purchase */ function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view { // solhint-disable-previous-line no-empty-blocks } /** * @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends * its tokens. * @param beneficiary Address performing the token purchase * @param tokenAmount Number of tokens to be emitted */ function _deliverTokens(address beneficiary, uint256 tokenAmount) internal { _token.safeTransfer(beneficiary, tokenAmount); } /** * @dev Executed when a purchase has been validated and is ready to be executed. Doesn't necessarily emit/send * tokens. * @param beneficiary Address receiving the tokens * @param tokenAmount Number of tokens to be purchased */ function _processPurchase(address beneficiary, uint256 tokenAmount) internal { _deliverTokens(beneficiary, tokenAmount); _addSold(tokenAmount); } /** * @dev Override for extensions that require an internal state to check for validity (current user contributions, * etc.) * @param beneficiary Address receiving the tokens * @param weiAmount Value in wei involved in the purchase */ function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal { // solhint-disable-previous-line no-empty-blocks } /** * @dev Override to extend the way in which ether is converted to tokens. * @param weiAmount Value in wei to be converted into tokens * @return Number of tokens that can be purchased with the specified _weiAmount */ function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) { return weiAmount.mul(_rate); } /** * @param tokenAmount amount of tokens to be converted in wei * @return amount of wei to be spent on the purchase of tokenAmount tokens */ function _getWeiAmount(uint256 tokenAmount) internal view returns (uint256) { return tokenAmount.div(_rate); } /** * @dev Determines how ETH is stored/forwarded on purchases. */ function _forwardFunds(uint256 weiAmount) internal { _wallet.transfer(weiAmount); } /* * @dev Override to define the way in which surplus will be counted * @param weiAmount Amount of wei sent by user * @return surplus to be returned */ function _countSurplus(uint256 weiAmount) internal returns (uint256){ // solhint-disable-previous-line no-empty-blocks } /** * @dev Override to change the way in which wei surplus returns to user * @param weiAmount Amount of wei to be returned */ function _returnSurplus(uint256 weiAmount) internal { if (weiAmount > 0) { msg.sender.transfer(weiAmount); } } /** * @dev Changes conversion rate. Override for extend the way in which rate changing affects on crowdsale * @param newRate Value in tokens to be paid per 1 wei */ function _changeRate(uint256 newRate) internal { if ((newRate > 0) && (_rate == 0)) { emit CrowdsaleUnpaused(); } else if (newRate == 0) { emit CrowdsalePaused(); } _rate = newRate; emit RateUpdated(newRate); } } // File: contracts/Crowdsale/Util/Role.sol pragma solidity ^0.5.2; library Role { struct RoleContainer { address[] bearer; } /** * @param role role storage * @return amount of accounts in this role */ function total (RoleContainer storage role) internal view returns (uint count) { for (uint i = 0; i < role.bearer.length; i++) { count += (role.bearer[i] == address(0)) ? 0 : 1; } return count; } /** * @dev check if an account has this role * @return bool */ function has(RoleContainer storage role, address account) internal view returns (bool) { require(account != address(0)); address[] memory list = role.bearer; uint len = role.bearer.length; for (uint index = 0; index < len; index++) { if (list[index] == account) { return true; } } return false; } /** * @dev give an account access to this role */ function add(RoleContainer storage role, address account) internal { require(account != address(0)); require(!has(role, account)); role.bearer.push(account); } /** * @dev remove an account's access to this role */ function remove(RoleContainer storage role, address account) internal { require(account != address(0)); require(has(role, account)); removeFromList(role, account); } /** * @dev Helper function. Iterates over array to find and remove given account from it @param role Role storage @param account Expelled account */ function removeFromList(RoleContainer storage role, address account) private { address[] storage list = role.bearer; uint len = role.bearer.length; for (uint index = 0; index <= len; index++) { if (list[index] != account) { continue; } list[index] = list[len - 1]; delete list[len - 1]; return; } } } // File: contracts/Crowdsale/Util/Helpers.sol pragma solidity ^0.5.2; library Helpers { function majority(uint total) internal pure returns (uint) { return uint(total / 2) + 1; } function idFromAddress(address addr) internal pure returns (bytes32) { return keccak256(abi.encode(addr)); } function idFromUint256(uint256 x) internal pure returns (bytes32) { return keccak256(abi.encode(x)); } function mixId(address addr, uint256 x) internal pure returns (bytes32) { return keccak256(abi.encode(addr, x)); } } // File: contracts/Crowdsale/Util/Votings.sol pragma solidity ^0.5.2; library Votings { struct Voting { mapping(bytes32 => address[]) process; } /** * @dev Votes and check if voting is completed. If vote is completed - deletes it * @param voting Storage * @param index Of voting process * @param issuer Voter * @param required Amount of votes for this process to be successful * @return (is voting completed?) */ function voteAndCheck(Voting storage voting, bytes32 index, address issuer, uint required) internal returns (bool) { vote(voting, index, issuer); return isComplete(voting, index, required); } /** * @dev Check if voting is completed. If vote is completed - deletes it * @param voting Storage * @param index Of voting process * @param required Amount of votes for this process to be successful * @return (is voting completed?) */ function isComplete(Voting storage voting, bytes32 index, uint required) internal returns (bool) { if (voting.process[index].length < required) { return false; } delete voting.process[index]; return true; } /** * @dev Vote * @param voting Storage * @param index Of voting process * @param issuer Voter */ function vote(Voting storage voting, bytes32 index, address issuer) internal { require(!hadVoted(voting, index, issuer)); voting.process[index].push(issuer); } /** * @dev Check of issuer had voted on this process * @param voting Storage * @param index Of voting process * @param issuer Voter * @return bool */ function hadVoted(Voting storage voting, bytes32 index, address issuer) internal view returns (bool) { address[] storage _process = voting.process[index]; for (uint ind = 0; ind < _process.length; ind++) { if (_process[ind] == issuer) { return true; } } return false; } } // File: contracts/Crowdsale/Roles/AdminRole.sol pragma solidity ^0.5.2; contract AdminRole { using Role for Role.RoleContainer; using Votings for Votings.Voting; //admin storage Role.RoleContainer private _admins; //voting storage Votings.Voting private _addVoting; Votings.Voting private _expelVoting; /** * @dev events for "add admin" action logging * @param account New admin */ event AdminAdded(address indexed account); /** * @dev events for "expel admin" action logging * @param account Expelled admin */ event AdminRemoved(address indexed account); modifier AdminOnly() { require(isAdmin(msg.sender)); _; } modifier WhileSetup() { require(isAdmin(msg.sender)); require(countAdmins() == 1); _; } constructor () internal { _add(msg.sender); } /** * @param account to check * @return is this account contains in admin list */ function isAdmin(address account) public view returns (bool) { return _admins.has(account); } /** * @return list of admins */ function listAdmins() public view returns (address[] memory) { return _admins.bearer; } /** * @return amount of admins */ function countAdmins() public view returns (uint) { return _admins.total(); } /** * @dev initialize admin list while setup-stage of sale * @param defaultAdmins list of default admins */ function initAdmins(address[] memory defaultAdmins) WhileSetup internal { for (uint256 index = 0; index < defaultAdmins.length; index++) { _add(defaultAdmins[index]); } } /** * @dev Vote and append given account to the admin list after consensus * @param account Account to be appended */ function addAdmin(address account) AdminOnly public { if (_addAdminVoting(account)) { _add(account); } } /** * @dev Vote and remove given account from admin list after consensus * @param account Account to be removed */ function expelAdmin(address account) AdminOnly public { if (_expelAdminVoting(account)) { _expel(account); } } /** * @dev require (N/2)+1 admins to be agreed with the add proposal * @param account Account to be appended * @return do (N/2)+1 admins agreed with the proposal? */ function _addAdminVoting(address account) private returns (bool) { return _addVoting.voteAndCheck( Helpers.idFromAddress(account), msg.sender, Helpers.majority(countAdmins()) ); } /** * @dev require (N/2)+1 admins to be agreed with the removal proposal * @param account Account to be removed * @return do (N/2)+1 admins agreed with the proposal? */ function _expelAdminVoting(address account) private returns (bool) { require(msg.sender != account); return _expelVoting.voteAndCheck( Helpers.idFromAddress(account), msg.sender, Helpers.majority(countAdmins()) ); } /** * @dev appends given account to admin list * @param account Account to be appended */ function _add(address account) private { _admins.add(account); emit AdminAdded(account); } /** * @dev removes given account to admin list * @param account Account to be excluded */ function _expel(address account) private { _admins.remove(account); emit AdminRemoved(account); } } // File: contracts/Crowdsale/Functionalities/InvestOnBehalf.sol pragma solidity ^0.5.2; contract InvestOnBehalf is AdminRole, Crowdsale { using Votings for Votings.Voting; // Current vote processes Votings.Voting private _votings; /** * Event for investOnBehalf actions logging * @param account Transfer target * @param tokens Amount of transferred tokens */ event InvestedOnBehalf(address indexed account, uint256 indexed tokens); /** * @dev require (N/2)+1 admins to be agreed with the proposal * @param account Transfer target * @param tokens Amount of tokens to be transferred * @return do all admins agreed with the proposal? */ function consensus(address account, uint256 tokens) private returns (bool) { return _votings.voteAndCheck(Helpers.mixId(account, tokens), msg.sender, Helpers.majority(countAdmins())); } /* * @dev Vote and add X tokens to the user balance after consensus * @param to Transfer target * @param tokens Amount of tokens to be transferred */ function investOnBehalf(address to, uint256 tokens) AdminOnly public { if (consensus(to, tokens)) { _processPurchase(to, tokens * 1e18); emit InvestedOnBehalf(to, tokens * 1e18); } } } // File: contracts/Crowdsale/Functionalities/MilestonedCrowdsale.sol pragma solidity ^0.5.2; contract MilestonedCrowdsale is AdminRole, Crowdsale { event MilestoneReached(uint256 indexed milestone); /** * @dev Container for milestone ranges * @param start Milestone start timestamp * @param finish Milestone finish timestamp * @param fired */ struct Milestone { uint256 start; uint256 finish; bool fired; } Milestone[] private _milestones; /** * @dev Creates single milestone in storage * @param start Timestamp from * @param finish Timestamp to */ function _newMilestone(uint256 start, uint256 finish) private { require(start < finish); _milestones.push(Milestone(start, finish, false)); } /** * @dev Initialize milestone storage * @param milestones Timerow of timestamps */ function initMilestones(uint256[] memory milestones) WhileSetup internal { for (uint256 index = 0; index < milestones.length - 1; index++) { _newMilestone(milestones[index], milestones[index + 1]); } } /** * @dev Extends parent with counting surplus from milestones * @param weiAmount Amount of wei received * @return surplus above the last milestone */ function _countSurplus(uint256 weiAmount) internal returns (uint256){ return _getMilestoneOverhead(weiAmount); } /** * @dev Extends parent with pausing crowdsale if any surplus is returned * @param weiAmount Amount of surplus wei */ function _returnSurplus(uint256 weiAmount) internal { super._returnSurplus(weiAmount); if (weiAmount > 0) { _changeRate(0); } } /** * @dev Iterates over milestones to make sure * that current transaction hasn't passed current milestone. * @param weiAmount Amount of wei received * @return If milestone has been reached, returns amount of wei above * milestone finish-line */ function _getMilestoneOverhead(uint256 weiAmount) private returns (uint256){ for (uint256 index = 0; index < _milestones.length; index++) { //every milestone could be reached only once if (_milestones[index].fired) { continue; } uint256 start = _milestones[index].start; uint256 finish = _milestones[index].finish; uint256 surplus = _checkStage(start, finish, weiAmount); if (surplus == 0) { continue; } _milestones[index].fired = true; emit MilestoneReached(finish); return surplus; } } /** * @param from Milestone start * @param to Milestone finish * @return surplus wei amount above the milestone */ function _checkStage(uint256 from, uint256 to, uint256 weiAmount) private view returns (uint256) { uint256 afterPayment = sold() + _getTokenAmount(weiAmount); bool inRange = (sold() >= from) && (sold() < to); if (inRange && (afterPayment >= to)) { return _getWeiAmount(afterPayment - to) + 1; } } } // File: contracts/Crowdsale/Functionalities/UpdatableRateCrowdsale.sol pragma solidity ^0.5.2; contract UpdatableRateCrowdsale is AdminRole, Crowdsale { using Votings for Votings.Voting; // Current vote processes Votings.Voting private _votings; /** * @dev require (N/2)+1 admins to be agreed with the proposal * @param rate New conversion rate * @return do (N/2)+1 admins agreed with the proposal? */ function consensus(uint256 rate) private returns (bool) { return _votings.voteAndCheck(Helpers.idFromUint256(rate), msg.sender, Helpers.majority(countAdmins())); } /** * @dev Vote and apply new conversion rates after consensus */ function changeRate(uint256 rate) AdminOnly public { if (consensus(rate)) { _changeRate(rate); } } } // File: contracts/Crowdsale/Core/Emission/MintedCrowdsale.sol pragma solidity ^0.5.2; /** * @title MintedCrowdsale * @dev Extension of Crowdsale contract whose tokens are minted in each purchase. * Token ownership should be transferred to MintedCrowdsale for minting. */ contract MintedCrowdsale is Crowdsale { /** * @dev Overrides delivery by minting tokens upon purchase. * @param beneficiary Token purchaser * @param tokenAmount Number of tokens to be minted */ function _deliverTokens(address beneficiary, uint256 tokenAmount) internal { // Potentially dangerous assumption about the type of the token. require(ERC20Mintable(address(token())).mint(beneficiary, tokenAmount)); } } // File: contracts/Crowdsale/Core/Validation/SoftcappedCrowdsale.sol pragma solidity ^0.5.2; contract SoftcappedCrowdsale is AdminRole, Crowdsale { // minimum amount of tokens to be sold uint256 private _goal; // minimum amount of wei to be accepted // from a single user before softcap collected uint256 private _minimalPay = 0; /** * @dev Constructor, creates RefundEscrow. * @param goal Funding goal */ constructor (uint256 goal) public { require(goal > 0); _goal = goal; } /** * @return minimum amount of tokens to be sold. */ function goal() public view returns (uint256) { return _goal; } /** * @return minimum amount of wei to be paid until softcap is reached. */ function minimalPay() public view returns (uint256) { return goalReached() ? 0 : _minimalPay; } /** * @return minimum amount of wei to be paid until softcap is reached. */ function setMinimalPay(uint256 weiAmount) WhileSetup internal { _minimalPay = weiAmount; } /** * @dev Checks whether funding goal was reached. * @return Whether funding goal was reached */ function goalReached() public view returns (bool) { return sold() >= _goal; } /** * @dev Extends parent with additional wei amount check sent by user * @param beneficiary Token purchaser * @param weiAmount Amount of received wei */ function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view { super._preValidatePurchase(beneficiary, weiAmount); if (!goalReached() && _minimalPay != 0) { require(weiAmount >= _minimalPay); } } } // File: contracts/Crowdsale/Core/Validation/TimedCrowdsale.sol pragma solidity ^0.5.2; /** * @title TimedCrowdsale * @dev Crowdsale closes if softcap not reached within a time frame. */ contract TimedCrowdsale is SoftcappedCrowdsale { using SafeMath for uint256; uint256 private _openingTime; uint256 private _softcapDeadline; uint256 private _closingTime; /** * Event for crowdsale extending * @param newClosingTime new closing time * @param prevClosingTime old closing time */ event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime); /** * @dev Reverts if not in crowdsale time range. */ modifier onlyWhileOpen { require(!hasClosed()); _; } /** * @dev Constructor, takes crowdsale opening and closing times. * @param openingTime Crowdsale opening time * @param softcapDeadline Crowdsale closing time */ constructor (uint256 openingTime, uint256 softcapDeadline, uint256 closingTime) public { // solhint-disable-next-line not-rely-on-time //todo require(openingTime >= block.timestamp); require(softcapDeadline > openingTime); require(closingTime > softcapDeadline); _openingTime = openingTime; _softcapDeadline = softcapDeadline; _closingTime = closingTime; } /** * @return the crowdsale opening time. */ function openingTime() public view returns (uint256) { return _openingTime; } /** * @return the crowdsale softcap deadline. */ function softcapDeadline() public view returns (uint256) { return _softcapDeadline; } /** * @return the crowdsale closing time. */ function closingTime() public view returns (uint256) { return _closingTime; } /** * @dev Checks whether the period in which the crowdsale is open has already elapsed. * @return Whether crowdsale period has elapsed and goal hasn't been reached */ function hasClosed() public view returns (bool) { // solhint-disable-next-line not-rely-on-time return ((block.timestamp > _softcapDeadline) && !goalReached()) || ((block.timestamp > _closingTime) && goalReached()); } /** * @dev Extend parent behavior requiring to be within contributing period * @param beneficiary Token purchaser * @param weiAmount Amount of wei contributed */ function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view { super._preValidatePurchase(beneficiary, weiAmount); } } // File: contracts/Crowdsale/Core/Distribution/FinalizableCrowdsale.sol pragma solidity ^0.5.2; /** * @title FinalizableCrowdsale * @dev Extension of TimedCrowdsale with a one-off finalization action, where one * can do extra work after finishing. */ contract FinalizableCrowdsale is AdminRole, TimedCrowdsale { using SafeMath for uint256; bool private _finalized; event CrowdsaleFinalized(); constructor () internal { _finalized = false; } /** * @return true if the crowdsale is finalized, false otherwise. */ function finalized() public view returns (bool) { return _finalized; } /** * @dev Must be called after crowdsale ends, to do some extra finalization * work. Calls the contract's finalization function. */ function finalize() AdminOnly public { require(!_finalized); require(hasClosed() || goalReached()); _finalized = true; _finalization(); emit CrowdsaleFinalized(); } /** * @dev Can be overridden to add finalization logic. The overriding function * should call super._finalization() to ensure the chain of finalization is * executed entirely. */ function _finalization() internal { // solhint-disable-previous-line no-empty-blocks } } // File: openzeppelin-solidity/contracts/ownership/Secondary.sol pragma solidity ^0.5.2; /** * @title Secondary * @dev A Secondary contract can only be used by its primary account (the one that created it) */ contract Secondary { address private _primary; event PrimaryTransferred( address recipient ); /** * @dev Sets the primary account to the one that is creating the Secondary contract. */ constructor () internal { _primary = msg.sender; emit PrimaryTransferred(_primary); } /** * @dev Reverts if called from any account other than the primary. */ modifier onlyPrimary() { require(msg.sender == _primary); _; } /** * @return the address of the primary. */ function primary() public view returns (address) { return _primary; } /** * @dev Transfers contract to a new primary. * @param recipient The address of new primary. */ function transferPrimary(address recipient) public onlyPrimary { require(recipient != address(0)); _primary = recipient; emit PrimaryTransferred(_primary); } } // File: openzeppelin-solidity/contracts/payment/escrow/Escrow.sol pragma solidity ^0.5.2; /** * @title Escrow * @dev Base escrow contract, holds funds designated for a payee until they * withdraw them. * @dev Intended usage: This contract (and derived escrow contracts) should be a * standalone contract, that only interacts with the contract that instantiated * it. That way, it is guaranteed that all Ether will be handled according to * the Escrow rules, and there is no need to check for payable functions or * transfers in the inheritance tree. The contract that uses the escrow as its * payment method should be its primary, and provide public methods redirecting * to the escrow's deposit and withdraw. */ contract Escrow is Secondary { using SafeMath for uint256; event Deposited(address indexed payee, uint256 weiAmount); event Withdrawn(address indexed payee, uint256 weiAmount); mapping(address => uint256) private _deposits; function depositsOf(address payee) public view returns (uint256) { return _deposits[payee]; } /** * @dev Stores the sent amount as credit to be withdrawn. * @param payee The destination address of the funds. */ function deposit(address payee) public onlyPrimary payable { uint256 amount = msg.value; _deposits[payee] = _deposits[payee].add(amount); emit Deposited(payee, amount); } /** * @dev Withdraw accumulated balance for a payee. * @param payee The address whose funds will be withdrawn and transferred to. */ function withdraw(address payable payee) public onlyPrimary { uint256 payment = _deposits[payee]; _deposits[payee] = 0; payee.transfer(payment); emit Withdrawn(payee, payment); } } // File: openzeppelin-solidity/contracts/payment/escrow/ConditionalEscrow.sol pragma solidity ^0.5.2; /** * @title ConditionalEscrow * @dev Base abstract escrow to only allow withdrawal if a condition is met. * @dev Intended usage: See Escrow.sol. Same usage guidelines apply here. */ contract ConditionalEscrow is Escrow { /** * @dev Returns whether an address is allowed to withdraw their funds. To be * implemented by derived contracts. * @param payee The destination address of the funds. */ function withdrawalAllowed(address payee) public view returns (bool); function withdraw(address payable payee) public { require(withdrawalAllowed(payee)); super.withdraw(payee); } } // File: contracts/Crowdsale/Core/Independent/RefundEscrow.sol pragma solidity ^0.5.2; /** * @title RefundEscrow * @dev Escrow that holds funds for a beneficiary, deposited from multiple * parties. * @dev Intended usage: See Escrow.sol. Same usage guidelines apply here. * @dev The primary account (that is, the contract that instantiates this * contract) may deposit, close the deposit period, and allow for either * withdrawal by the beneficiary, or refunds to the depositors. All interactions * with RefundEscrow will be made through the primary contract. See the * RefundableCrowdsale contract for an example of RefundEscrow’s use. */ contract RefundEscrow is ConditionalEscrow { enum State { Active, Refunding, Closed } event RefundsClosed(); event RefundsEnabled(); State private _state; address payable private _beneficiary; /** * @dev Constructor. * @param beneficiary The beneficiary of the deposits. */ constructor (address payable beneficiary) public { require(beneficiary != address(0)); _beneficiary = beneficiary; _state = State.Active; } /** * @return the current state of the escrow. */ function state() public view returns (State) { return _state; } /** * @return the beneficiary of the escrow. */ function beneficiary() public view returns (address) { return _beneficiary; } /** * @dev Stores funds that may later be refunded. * @param refundee The address funds will be sent to if a refund occurs. */ function deposit(address refundee) public payable { require(_state == State.Active); super.deposit(refundee); } /** * @dev Allows for the beneficiary to withdraw their funds, rejecting * further deposits. */ function close() public onlyPrimary { require(_state == State.Active); _state = State.Closed; emit RefundsClosed(); } /** * @dev Allows for refunds to take place, rejecting further deposits. */ function enableRefunds() public onlyPrimary { require(_state == State.Active); _state = State.Refunding; emit RefundsEnabled(); } /** * @dev Withdraws the beneficiary's funds. */ function beneficiaryWithdraw() public onlyPrimary { _beneficiary.transfer(address(this).balance); } /** * @dev Withdraws the beneficiary's funds. */ function customWithdraw(uint256 etherAmount, address payable account) public onlyPrimary { account.transfer(etherAmount); } /** * @dev Returns whether refundees can withdraw their deposits (be refunded). The overridden function receives a * 'payee' argument, but we ignore it here since the condition is global, not per-payee. */ function withdrawalAllowed(address) public view returns (bool) { return _state == State.Refunding; } } // File: contracts/Crowdsale/Core/Distribution/RefundableCrowdsale.sol pragma solidity ^0.5.2; /** * @title RefundableCrowdsale * @dev Extension of FinalizableCrowdsale contract that adds a funding goal, and the possibility of users * getting a refund if goal is not met. * * Deprecated, use RefundablePostDeliveryCrowdsale instead. Note that if you allow tokens to be traded before the goal * is met, then an attack is possible in which the attacker purchases tokens from the crowdsale and when they sees that * the goal is unlikely to be met, they sell their tokens (possibly at a discount). The attacker will be refunded when * the crowdsale is finalized, and the users that purchased from them will be left with worthless tokens. */ contract RefundableCrowdsale is FinalizableCrowdsale { using SafeMath for uint256; using Votings for Votings.Voting; event FundsWithdraw(uint256 indexed etherAmount, address indexed account); // Current vote processes Votings.Voting private _votings; // refund escrow used to hold funds while crowdsale is running RefundEscrow private _escrow; /** * @dev Constructor, creates RefundEscrow. */ constructor () public { _escrow = new RefundEscrow(wallet()); } /** * @dev Investors can claim refunds here if crowdsale is unsuccessful * @param refundee Whose refund will be claimed. */ function claimRefund(address payable refundee) public { require(finalized()); require(!goalReached()); _escrow.withdraw(refundee); } function beneficiaryWithdraw(uint256 etherAmount, address payable account) AdminOnly public { if (goalReached() && consensus(etherAmount, address(account))) { _escrow.customWithdraw(etherAmount * 1e18, account); emit FundsWithdraw(etherAmount * 1e18, address(account)); } } /** * @dev escrow finalization task, called when finalize() is called */ function _finalization() internal { if (goalReached()) { _escrow.close(); _escrow.beneficiaryWithdraw(); } else { uint256 day = 86400; require(block.timestamp > softcapDeadline() + day); _escrow.enableRefunds(); } super._finalization(); } /** * @dev Overrides Crowdsale fund forwarding, sending funds to escrow. */ function _forwardFunds(uint256 weiAmount) internal { _escrow.deposit.value(weiAmount)(msg.sender); } /** * @dev require (N/2)+1 admins to be agreed with the proposal * @return do all admins agreed with the proposal? */ function consensus(uint256 etherAmount, address account) private returns (bool) { return _votings.voteAndCheck( Helpers.mixId(account, etherAmount), msg.sender, Helpers.majority(countAdmins()) ); } } // File: contracts/Crowdsale/Core/Distribution/PostDeliveryCrowdsale.sol pragma solidity ^0.5.2; /** * @title PostDeliveryCrowdsale * @dev Crowdsale that locks tokens from withdrawal until it ends. */ contract PostDeliveryCrowdsale is TimedCrowdsale { using SafeMath for uint256; /** * @dev contains virtual balances. * All balance records are written * here until softcap is reached */ mapping(address => uint256) private _balances; /** * @dev list of backers with virtual balances */ address[] private _backers; /** * @dev Withdraw tokens only after crowdsale ends. * @param beneficiary Whose tokens will be withdrawn. */ function withdrawTokens(address beneficiary) public { require(goalReached()); uint256 amount = _balances[beneficiary]; require(amount > 0); _balances[beneficiary] = 0; _deliverTokens(beneficiary, amount); } /** * @return the balance of an account. */ function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function backers() public view returns (address[] memory) { return _backers; } /** * @dev Overrides parent by storing balances instead of issuing tokens right away. * @param beneficiary Token purchaser * @param tokenAmount Amount of tokens purchased */ function _processPurchase(address beneficiary, uint256 tokenAmount) internal { if (!goalReached()) { _balances[beneficiary] = _balances[beneficiary].add(tokenAmount); _backers.push(beneficiary); _addSold(tokenAmount); return; } super._processPurchase(beneficiary, tokenAmount); } } // File: contracts/Crowdsale/Core/Distribution/RefundablePostDeliveryCrowdsale.sol pragma solidity ^0.5.2; /** * @title RefundablePostDeliveryCrowdsale * @dev Extension of RefundableCrowdsale contract that only delivers the tokens * once the crowdsale has the goal met, preventing refunds to be issued * to token holders. */ contract RefundablePostDeliveryCrowdsale is RefundableCrowdsale, PostDeliveryCrowdsale { function withdrawTokens(address beneficiary) public { require(goalReached()); super.withdrawTokens(beneficiary); } } // File: contracts/Crowdsale/Moon_Token_Crowdsale.sol pragma solidity ^0.5.2; /* Moon Token for MoonTrader Platform and projects More information at https://moontrader.io/ MoonTrader is a successor of the MoonBot project, https://moon-bot.com/en/ Mail us to: [email protected] Join the Telegram channel https://t.me/moontrader_news_en, Visit BTT forum thread https://bitcointalk.org/index.php?topic=5143969 for more information. */ contract Moon_Token_Crowdsale is UpdatableRateCrowdsale, MilestonedCrowdsale, InvestOnBehalf, MintedCrowdsale, RefundablePostDeliveryCrowdsale { constructor( ERC20Mintable _token, address payable _wallet, uint256 _rate, uint256 _supply, uint256 _softcap, uint256 _open, uint256 _softline, uint256 _close ) public Crowdsale(_rate, _supply, _wallet, _token) TimedCrowdsale(_open, _softline, _close) SoftcappedCrowdsale(_softcap){ } /** * @dev finish contract initialization. Made because of "stack size". * @param _minimalPay amount in wei * @param admins list * @param milestones list */ function finishSetup( uint256 _minimalPay, uint256[] memory milestones, address[] memory admins ) WhileSetup public { setMinimalPay(_minimalPay); initMilestones(milestones); initAdmins(admins); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"constant":true,"inputs":[],"name":"sold","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"softcapDeadline","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"hasClosed","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"countAdmins","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"isAdmin","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"goal","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"weiRaised","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"}],"name":"withdrawTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"closingTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"finalize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"wallet","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"minimalPay","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_minimalPay","type":"uint256"},{"name":"milestones","type":"uint256[]"},{"name":"admins","type":"address[]"}],"name":"finishSetup","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"account","type":"address"}],"name":"addAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"rate","type":"uint256"}],"name":"changeRate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"goalReached","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"backers","outputs":[{"name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"etherAmount","type":"uint256"},{"name":"account","type":"address"}],"name":"beneficiaryWithdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"listAdmins","outputs":[{"name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"finalized","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"openingTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"account","type":"address"}],"name":"expelAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"refundee","type":"address"}],"name":"claimRefund","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"tokens","type":"uint256"}],"name":"investOnBehalf","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"}],"name":"buyTokens","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_token","type":"address"},{"name":"_wallet","type":"address"},{"name":"_rate","type":"uint256"},{"name":"_supply","type":"uint256"},{"name":"_softcap","type":"uint256"},{"name":"_open","type":"uint256"},{"name":"_softline","type":"uint256"},{"name":"_close","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"etherAmount","type":"uint256"},{"indexed":true,"name":"account","type":"address"}],"name":"FundsWithdraw","type":"event"},{"anonymous":false,"inputs":[],"name":"CrowdsaleFinalized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"prevClosingTime","type":"uint256"},{"indexed":false,"name":"newClosingTime","type":"uint256"}],"name":"TimedCrowdsaleExtended","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"},{"indexed":true,"name":"tokens","type":"uint256"}],"name":"InvestedOnBehalf","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"milestone","type":"uint256"}],"name":"MilestoneReached","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"purchaser","type":"address"},{"indexed":true,"name":"beneficiary","type":"address"},{"indexed":false,"name":"value","type":"uint256"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"TokensPurchased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"rate","type":"uint256"}],"name":"RateUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"CrowdsalePaused","type":"event"},{"anonymous":false,"inputs":[],"name":"CrowdsaleUnpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"AdminAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"AdminRemoved","type":"event"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000d47a07070bd8a670407038941318783cf2070a1e000000000000000000000000d0efb8e61384601e0b119cf8d2501c3144e0648800000000000000000000000000000000000000000000000000000000000000fd000000000000000000000000000000000000000000027b46536c66c8e300000000000000000000000000000000000000000000000001287626ee52197b000000000000000000000000000000000000000000000000000000000000005cdb5680000000000000000000000000000000000000000000000000000000005d38f100000000000000000000000000000000000000000000000000000000005db23b00
-----Decoded View---------------
Arg [0] : _token (address): 0xd47A07070bD8A670407038941318783cF2070a1e
Arg [1] : _wallet (address): 0xD0efB8e61384601E0B119Cf8D2501C3144e06488
Arg [2] : _rate (uint256): 253
Arg [3] : _supply (uint256): 3000000000000000000000000
Arg [4] : _softcap (uint256): 1400000000000000000000000
Arg [5] : _open (uint256): 1557878400
Arg [6] : _softline (uint256): 1564012800
Arg [7] : _close (uint256): 1571961600
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 000000000000000000000000d47a07070bd8a670407038941318783cf2070a1e
Arg [1] : 000000000000000000000000d0efb8e61384601e0b119cf8d2501c3144e06488
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000fd
Arg [3] : 000000000000000000000000000000000000000000027b46536c66c8e3000000
Arg [4] : 00000000000000000000000000000000000000000001287626ee52197b000000
Arg [5] : 000000000000000000000000000000000000000000000000000000005cdb5680
Arg [6] : 000000000000000000000000000000000000000000000000000000005d38f100
Arg [7] : 000000000000000000000000000000000000000000000000000000005db23b00
Deployed Bytecode Sourcemap
63648:1008:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22885:21;22895:10;22885:9;:21::i;:::-;63648:1008;23273:77;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23273:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48285:99;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48285:99:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48746:249;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48746:249:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;36016:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;36016:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;35692:107;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35692:107:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;35692:107:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;23852:77;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23852:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45461;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45461:77:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;23997:87;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23997:87:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;63007:137;;8:9:-1;5:2;;;30:1;27;20:12;5:2;63007:137:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;63007:137:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;48454:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48454:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50216:218;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50216:218:0;;;:::i;:::-;;23673:89;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23673:89:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;45639:109;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45639:109:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;64394:259;;8:9:-1;5:2;;;30:1;27;20:12;5:2;64394:259:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;64394:259:0;;;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;64394:259:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;64394:259:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;64394:259:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;64394:259:0;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;64394:259:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;64394:259:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;64394:259:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;64394:259:0;;;;;;;;;;;;;;;:::i;:::-;;36601:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;36601:140:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;36601:140:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;61774:110;;8:9:-1;5:2;;;30:1;27;20:12;5:2;61774:110:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;61774:110:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;43910:134;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43910:134:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;43910:134:0;;;;;;;;;;;;;;;;;:::i;:::-;;46082:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46082:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;61892:92;;8:9:-1;5:2;;;30:1;27;20:12;5:2;61892:92:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;61892:92:0;;;;;;;;;;;;;;;;;59329:322;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59329:322:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;59329:322:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;35856:101;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35856:101:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;35856:101:0;;;;;;;;;;;;;;;;;49968:84;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49968:84:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;48120:91;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48120:91:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36887:146;;8:9:-1;5:2;;;30:1;27;20:12;5:2;36887:146:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;36887:146:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;59155:166;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59155:166:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;59155:166:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;39592:231;;8:9:-1;5:2;;;30:1;27;20:12;5:2;39592:231:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;39592:231:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24351:751;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;24351:751:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;22978:78;;8:9:-1;5:2;;;30:1;27;20:12;5:2;22978:78:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;24351:751;19476:1;19459:13;;:18;;;;;;;;;;;19488:20;19511:13;;19488:36;;24430:17;24450:9;24430:29;;24470:44;24491:11;24504:9;24470:20;:44::i;:::-;24527:15;24545:24;24559:9;24545:13;:24::i;:::-;24527:42;;24593:7;24580:20;;;;24662:14;24679:26;24695:9;24679:15;:26::i;:::-;24662:43;;24756:25;24771:9;24756:10;;:14;;:25;;;;:::i;:::-;24743:10;:38;;;;24794:37;24811:11;24824:6;24794:16;:37::i;:::-;24875:11;24847:59;;24863:10;24847:59;;;24888:9;24899:6;24847:59;;;;;;;;;;;;;;;;;;;;;;;;24919:46;24942:11;24955:9;24919:22;:46::i;:::-;24978:24;24992:9;24978:13;:24::i;:::-;25013:23;25028:7;25013:14;:23::i;:::-;25049:45;25071:11;25084:9;25049:21;:45::i;:::-;19535:1;;;19571:13;;19555:12;:29;19547:38;;;;;;24351:751;;:::o;23273:77::-;23310:7;23337:5;;23330:12;;23273:77;:::o;48285:99::-;48333:7;48360:16;;48353:23;;48285:99;:::o;48746:249::-;48788:4;48887:16;;48869:15;:34;48868:54;;;;;48909:13;:11;:13::i;:::-;48908:14;48868:54;48867:120;;;;48956:12;;48938:15;:30;48937:49;;;;;48973:13;:11;:13::i;:::-;48937:49;48867:120;48860:127;;48746:249;:::o;36016:91::-;36060:4;36084:15;:7;:13;:15::i;:::-;36077:22;;36016:91;:::o;35692:107::-;35747:4;35771:20;35783:7;35771;:11;;:20;;;;:::i;:::-;35764:27;;35692:107;;;:::o;23852:77::-;23889:7;23916:5;;23909:12;;23852:77;:::o;45461:::-;45498:7;45525:5;;45518:12;;45461:77;:::o;23997:87::-;24039:7;24066:10;;24059:17;;23997:87;:::o;63007:137::-;63078:13;:11;:13::i;:::-;63070:22;;;;;;63103:33;63124:11;63103:20;:33::i;:::-;63007:137;:::o;48454:91::-;48498:7;48525:12;;48518:19;;48454:91;:::o;50216:218::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;50273:10;;;;;;;;;;;50272:11;50264:20;;;;;;50303:11;:9;:11::i;:::-;:28;;;;50318:13;:11;:13::i;:::-;50303:28;50295:37;;;;;;50358:4;50345:10;;:17;;;;;;;;;;;;;;;;;;50375:15;:13;:15::i;:::-;50406:20;;;;;;;;;;50216:218::o;23673:89::-;23712:15;23747:7;;;;;;;;;;;23740:14;;23673:89;:::o;45639:109::-;45682:7;45709:13;:11;:13::i;:::-;:31;;45729:11;;45709:31;;;45725:1;45709:31;45702:38;;45639:109;:::o;64394:259::-;35434:19;35442:10;35434:7;:19::i;:::-;35426:28;;;;;;35490:1;35473:13;:11;:13::i;:::-;:18;35465:27;;;;;;64553:26;64567:11;64553:13;:26::i;:::-;64590;64605:10;64590:14;:26::i;:::-;64627:18;64638:6;64627:10;:18::i;:::-;64394:259;;;:::o;36601:140::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;36668:24;36684:7;36668:15;:24::i;:::-;36664:70;;;36709:13;36714:7;36709:4;:13::i;:::-;36664:70;36601:140;:::o;61774:110::-;61831:7;61858:9;:18;61868:7;61858:18;;;;;;;;;;;;;;;;61851:25;;61774:110;;;:::o;43910:134::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;43976:15;43986:4;43976:9;:15::i;:::-;43972:65;;;44008:17;44020:4;44008:11;:17::i;:::-;43972:65;43910:134;:::o;46082:91::-;46126:4;46160:5;;46150:6;:4;:6::i;:::-;:15;;46143:22;;46082:91;:::o;61892:92::-;61932:16;61968:8;61961:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61892:92;:::o;59329:322::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;59436:13;:11;:13::i;:::-;:57;;;;;59453:40;59463:11;59484:7;59453:9;:40::i;:::-;59436:57;59432:212;;;59510:7;;;;;;;;;;;:22;;;59547:4;59533:11;:18;59553:7;59510:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59510:51:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59510:51:0;;;;59623:7;59581:51;;59609:4;59595:11;:18;59581:51;;;;;;;;;;59432:212;59329:322;;:::o;35856:101::-;35899:16;35935:7;:14;;35928:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35856:101;:::o;49968:84::-;50010:4;50034:10;;;;;;;;;;;50027:17;;49968:84;:::o;48120:91::-;48164:7;48191:12;;48184:19;;48120:91;:::o;36887:146::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;36956:26;36974:7;36956:17;:26::i;:::-;36952:74;;;36999:15;37006:7;36999:6;:15::i;:::-;36952:74;36887:146;:::o;59155:166::-;59228:11;:9;:11::i;:::-;59220:20;;;;;;59260:13;:11;:13::i;:::-;59259:14;59251:23;;;;;;59287:7;;;;;;;;;;;:16;;;59304:8;59287:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59287:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59287:26:0;;;;59155:166;:::o;39592:231::-;35345:19;35353:10;35345:7;:19::i;:::-;35337:28;;;;;;39676:21;39686:2;39690:6;39676:9;:21::i;:::-;39672:144;;;39714:35;39731:2;39744:4;39735:6;:13;39714:16;:35::i;:::-;39799:4;39790:6;:13;39786:2;39769:35;;;;;;;;;;;;39672:144;39592:231;;:::o;22978:78::-;23016:6;23042;;;;;;;;;;;23035:13;;22978:78;:::o;49194:167::-;47393:11;:9;:11::i;:::-;47392:12;47384:21;;;;;;49303:50;49330:11;49343:9;49303:26;:50::i;:::-;49194:167;;:::o;41217:126::-;41277:7;41303:32;41325:9;41303:21;:32::i;:::-;41296:39;;41217:126;;;:::o;27932:122::-;27999:7;28026:20;28040:5;;28026:9;:13;;:20;;;;:::i;:::-;28019:27;;27932:122;;;:::o;2801:150::-;2859:7;2879:9;2895:1;2891;:5;2879:17;;2920:1;2915;:6;;2907:15;;;;;;2942:1;2935:8;;;2801:150;;;;:::o;62195:363::-;62288:13;:11;:13::i;:::-;62283:209;;62343:39;62370:11;62343:9;:22;62353:11;62343:22;;;;;;;;;;;;;;;;:26;;:39;;;;:::i;:::-;62318:9;:22;62328:11;62318:22;;;;;;;;;;;;;;;:64;;;;62397:8;62411:11;62397:26;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;62397:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62438:21;62447:11;62438:8;:21::i;:::-;62474:7;;62283:209;62502:48;62525:11;62538;62502:22;:48::i;:::-;62195:363;;;:::o;27529:147::-;;;:::o;60196:114::-;60258:7;;;;;;;;;;;:15;;;60280:9;60291:10;60258:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;60258:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;60258:44:0;;;;;60196:114;:::o;41494:174::-;41557:31;41578:9;41557:20;:31::i;:::-;41617:1;41605:9;:13;41601:60;;;41635:14;41647:1;41635:11;:14::i;:::-;41601:60;41494:174;:::o;26231:151::-;;;:::o;29917:240::-;29984:10;30012:6;30021:1;30012:10;;30007:120;30028:4;:11;;:18;;;;30024:1;:22;30007:120;;;30104:1;30078:28;;:4;:11;;30090:1;30078:14;;;;;;;;;;;;;;;;;;;;;;;;;:28;;;30077:38;;30114:1;30077:38;;;30110:1;30077:38;30068:47;;;;;;30048:3;;;;;;;30007:120;;;;30144:5;30137:12;;29917:240;;;:::o;30253:398::-;30334:4;30378:1;30359:21;;:7;:21;;;;30351:30;;;;;;30392:21;30416:4;:11;;30392:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30438:8;30449:4;:11;;:18;;;;30438:29;;30483:10;30496:1;30483:14;;30478:143;30507:3;30499:5;:11;30478:143;;;30555:7;30540:22;;:4;30545:5;30540:11;;;;;;;;;;;;;;:22;;;30536:74;;;30590:4;30583:11;;;;;;;30536:74;30512:7;;;;;;;30478:143;;;;30638:5;30631:12;;;;30253:398;;;;;:::o;61449:256::-;61520:13;:11;:13::i;:::-;61512:22;;;;;;61545:14;61562:9;:22;61572:11;61562:22;;;;;;;;;;;;;;;;61545:39;;61612:1;61603:6;:10;61595:19;;;;;;61650:1;61625:9;:22;61635:11;61625:22;;;;;;;;;;;;;;;:26;;;;61662:35;61677:11;61690:6;61662:14;:35::i;:::-;61449:256;;:::o;59749:346::-;59798:13;:11;:13::i;:::-;59794:260;;;59828:7;;;;;;;;;;;:13;;;:15;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59828:15:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59828:15:0;;;;59858:7;;;;;;;;;;;:27;;;:29;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;59858:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59858:29:0;;;;59794:260;;;59920:11;59934:5;59920:19;;60000:3;59980:17;:15;:17::i;:::-;:23;59962:15;:41;59954:50;;;;;;60019:7;;;;;;;;;;;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;60019:23:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;60019:23:0;;;;59794:260;;60066:21;:19;:21::i;:::-;59749:346::o;45849:104::-;35434:19;35442:10;35434:7;:19::i;:::-;35426:28;;;;;;35490:1;35473:13;:11;:13::i;:::-;:18;35465:27;;;;;;45936:9;45922:11;:23;;;;45849:104;:::o;40791:237::-;35434:19;35442:10;35434:7;:19::i;:::-;35426:28;;;;;;35490:1;35473:13;:11;:13::i;:::-;:18;35465:27;;;;;;40880:13;40896:1;40880:17;;40875:146;40927:1;40907:10;:17;:21;40899:5;:29;40875:146;;;40954:55;40968:10;40979:5;40968:17;;;;;;;;;;;;;;40987:10;41006:1;40998:5;:9;40987:21;;;;;;;;;;;;;;40954:13;:55::i;:::-;40930:7;;;;;;;40875:146;;;;40791:237;:::o;36246:206::-;35434:19;35442:10;35434:7;:19::i;:::-;35426:28;;;;;;35490:1;35473:13;:11;:13::i;:::-;:18;35465:27;;;;;;36334:13;36350:1;36334:17;;36329:116;36361:13;:20;36353:5;:28;36329:116;;;36407:26;36412:13;36426:5;36412:20;;;;;;;;;;;;;;36407:4;:26::i;:::-;36383:7;;;;;;;36329:116;;;;36246:206;:::o;37239:241::-;37298:4;37322:150;37360:30;37382:7;37360:21;:30::i;:::-;37405:10;37430:31;37447:13;:11;:13::i;:::-;37430:16;:31::i;:::-;37322:10;:23;;:150;;;;;;:::i;:::-;37315:157;;37239:241;;;:::o;38096:113::-;38146:20;38158:7;38146;:11;;:20;;;;:::i;:::-;38193:7;38182:19;;;;;;;;;;;;38096:113;:::o;43642:177::-;43692:4;43716:95;43738:27;43760:4;43738:21;:27::i;:::-;43767:10;43779:31;43796:13;:11;:13::i;:::-;43779:16;:31::i;:::-;43716:8;:21;;:95;;;;;;:::i;:::-;43709:102;;43642:177;;;:::o;29362:288::-;29435:1;29425:7;:11;29424:29;;;;;29451:1;29442:5;;:10;29424:29;29420:159;;;29475:19;;;;;;;;;;29420:159;;;29527:1;29516:7;:12;29512:67;;;29550:17;;;;;;;;;;29512:67;29420:159;29599:7;29591:5;:15;;;;29634:7;29622:20;;;;;;;;;;29362:288;:::o;60453:259::-;60527:4;60551:153;60587:35;60601:7;60610:11;60587:13;:35::i;:::-;60637:10;60662:31;60679:13;:11;:13::i;:::-;60662:16;:31::i;:::-;60551:8;:21;;:153;;;;;;:::i;:::-;60544:160;;60453:259;;;;:::o;37687:286::-;37748:4;37787:7;37773:21;;:10;:21;;;;37765:30;;;;;;37813:152;37853:30;37875:7;37853:21;:30::i;:::-;37898:10;37923:31;37940:13;:11;:13::i;:::-;37923:16;:31::i;:::-;37813:12;:25;;:152;;;;;;:::i;:::-;37806:159;;37687:286;;;:::o;38330:120::-;38382:23;38397:7;38382;:14;;:23;;;;:::i;:::-;38434:7;38421:21;;;;;;;;;;;;38330:120;:::o;39204:199::-;39273:4;39297:98;39319:30;39333:7;39342:6;39319:13;:30::i;:::-;39351:10;39363:31;39380:13;:11;:13::i;:::-;39363:16;:31::i;:::-;39297:8;:21;;:98;;;;;;:::i;:::-;39290:105;;39204:199;;;;:::o;46364:265::-;46459:50;46486:11;46499:9;46459:26;:50::i;:::-;46527:13;:11;:13::i;:::-;46526:14;:34;;;;;46559:1;46544:11;;:16;;46526:34;46522:100;;;46598:11;;46585:9;:24;;46577:33;;;;;;46522:100;46364:265;;:::o;41964:695::-;42031:7;42055:13;42071:1;42055:17;;42050:602;42082:11;:18;;;;42074:5;:26;42050:602;;;42188:11;42200:5;42188:18;;;;;;;;;;;;;;;;;;:24;;;;;;;;;;;;42184:73;;;42233:8;;42184:73;42273:13;42289:11;42301:5;42289:18;;;;;;;;;;;;;;;;;;:24;;;42273:40;;42328:14;42345:11;42357:5;42345:18;;;;;;;;;;;;;;;;;;:25;;;42328:42;;42387:15;42405:37;42417:5;42424:6;42432:9;42405:11;:37::i;:::-;42387:55;;42472:1;42461:7;:12;42457:61;;;42494:8;;;;;42457:61;42561:4;42534:11;42546:5;42534:18;;;;;;;;;;;;;;;;;;:24;;;:31;;;;;;;;;;;;;;;;;;42602:6;42585:24;;;;;;;;;;42633:7;42626:14;;;;;;;;42050:602;42102:7;;;;;;;42050:602;;;;41964:695;;;;:::o;1554:433::-;1612:7;1861:1;1856;:6;1852:47;;;1886:1;1879:8;;;;1852:47;1911:9;1927:1;1923;:5;1911:17;;1956:1;1951;1947;:5;;;;;;:10;1939:19;;;;;;1978:1;1971:8;;;1554:433;;;;;:::o;23495:97::-;23562:22;23572:11;23562:5;;:9;;:22;;;;:::i;:::-;23554:5;:30;;;;23495:97;:::o;27083:168::-;27171:40;27186:11;27199;27171:14;:40::i;:::-;27222:21;27231:11;27222:8;:21::i;:::-;27083:168;;:::o;29020:146::-;29099:1;29087:9;:13;29083:76;;;29117:10;:19;;:30;29137:9;29117:30;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29117:30:0;29083:76;29020:146;:::o;44570:239::-;44760:7;:5;:7::i;:::-;44738:36;;;44775:11;44788;44738:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44738:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44738:62:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;44738:62:0;;;;;;;;;;;;;;;;44730:71;;;;;;44570:239;;:::o;50650:100::-;:::o;40511:164::-;40600:6;40592:5;:14;40584:23;;;;;;40618:11;40635:31;;;;;;;;40645:5;40635:31;;;;40652:6;40635:31;;;;40660:5;40635:31;;;;;40618:49;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;40618:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40511:164;;:::o;32036:122::-;32096:7;32144:4;32133:16;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;32133:16:0;;;32123:27;;;;;;32116:34;;32036:122;;;:::o;31924:104::-;31977:4;32019:1;32014;32006:5;:9;;;;;;32001:19;31994:26;;31924:104;;;:::o;32921:228::-;33039:4;33061:27;33066:6;33074:5;33081:6;33061:4;:27::i;:::-;33106:35;33117:6;33125:5;33132:8;33106:10;:35::i;:::-;33099:42;;32921:228;;;;;;:::o;30726:193::-;30831:1;30812:21;;:7;:21;;;;30804:30;;;;;;30854:18;30858:4;30864:7;30854:3;:18::i;:::-;30853:19;30845:28;;;;;;30886:4;:11;;30903:7;30886:25;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;30886:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30726:193;;:::o;32166:116::-;32223:7;32271:1;32260:13;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;32260:13:0;;;32250:24;;;;;;32243:31;;32166:116;;;:::o;32290:128::-;32353:7;32401:4;32407:1;32390:19;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;32390:19:0;;;32380:30;;;;;;32373:37;;32290:128;;;;:::o;30998:199::-;31106:1;31087:21;;:7;:21;;;;31079:30;;;;;;31128:18;31132:4;31138:7;31128:3;:18::i;:::-;31120:27;;;;;;31160:29;31175:4;31181:7;31160:14;:29::i;:::-;30998:199;;:::o;25655:273::-;25781:1;25758:25;;:11;:25;;;;25750:34;;;;;;25816:1;25803:9;:14;;25795:23;;;;;;25846:1;25837:6;:4;:6::i;:::-;:10;25829:19;;;;;;25886:26;25902:9;25886:15;:26::i;:::-;25878:5;;:34;25867:7;;:45;;25859:54;;;;;;25655:273;;:::o;42811:352::-;42899:7;42919:20;42951:26;42967:9;42951:15;:26::i;:::-;42942:6;:4;:6::i;:::-;:35;42919:58;;42988:12;43014:4;43004:6;:4;:6::i;:::-;:14;;43003:33;;;;;43033:2;43024:6;:4;:6::i;:::-;:11;43003:33;42988:48;;43053:7;:31;;;;;43081:2;43065:12;:18;;43053:31;43049:107;;;43143:1;43108:32;43137:2;43122:12;:17;43108:13;:32::i;:::-;:36;43101:43;;;;;;43049:107;42811:352;;;;;;;;:::o;33855:196::-;33966:31;33975:6;33983:5;33990:6;33966:8;:31::i;:::-;33965:32;33957:41;;;;;;34009:6;:14;;:21;34024:5;34009:21;;;;;;;;;;;34036:6;34009:34;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;34009:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33855:196;;;:::o;33434:276::-;33534:4;33591:8;33560:6;:14;;:21;33575:5;33560:21;;;;;;;;;;;:28;;;;:39;33556:84;;;33623:5;33616:12;;;;33556:84;33659:6;:14;;:21;33674:5;33659:21;;;;;;;;;;;;33652:28;;;;:::i;:::-;33698:4;33691:11;;33434:276;;;;;;:::o;31395:423::-;31483:22;31508:4;:11;;31483:36;;31530:8;31541:4;:11;;:18;;;;31530:29;;31577:10;31590:1;31577:14;;31572:239;31602:3;31593:5;:12;31572:239;;31650:7;31635:22;;:4;31640:5;31635:11;;;;;;;;;;;;;;;;;;;;;;;;;:22;;;31631:71;;31678:8;;31631:71;31730:4;31741:1;31735:3;:7;31730:13;;;;;;;;;;;;;;;;;;;;;;;;;31716:4;31721:5;31716:11;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;31765:4;31776:1;31770:3;:7;31765:13;;;;;;;;;;;;;;;;31758:20;;;;;;;;;;;31793:7;;;;;31572:239;31607:7;;;;;;;31572:239;;;;31395:423;;;;;:::o;28227:124::-;28294:7;28321:22;28337:5;;28321:11;:15;;:22;;;;:::i;:::-;28314:29;;28227:124;;;:::o;34250:371::-;34354:4;34376:26;34405:6;:14;;:21;34420:5;34405:21;;;;;;;;;;;34376:50;;34444:8;34455:1;34444:12;;34439:150;34464:8;:15;;;;34458:3;:21;34439:150;;;34524:6;34507:23;;:8;34516:3;34507:13;;;;;;;;;;;;;;;;;;;;;;;;;:23;;;34503:75;;;34558:4;34551:11;;;;;;34503:75;34481:5;;;;;;;34439:150;;;;34608:5;34601:12;;;34250:371;;;;;;:::o;2122:303::-;2180:7;2279:1;2275;:5;2267:14;;;;;;2292:9;2308:1;2304;:5;;;;;;2292:17;;2416:1;2409:8;;;2122:303;;;;:::o;63648:1008::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o
Swarm Source
bzzr://01723f6d328303dc35624389b38ce745521fba0e5e327c113a8ff3dca931df52
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $0.999189 | 1.3 | $1.3 |
Loading...
Loading
[ Download: CSV Export ]
[ 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.