Contract Overview
Balance:
0 AVAX
AVAX Value:
$0.00
My Name Tag:
Not Available, login to update
Txn Hash | Method |
Block
|
From
|
To
|
Value | [Txn Fee] | |||
---|---|---|---|---|---|---|---|---|---|
0xf1698f564725f45b994fb716510ded097b76b06f5d30926f58b892ba202e6d93 | 0x60806040 | 20917746 | 170 days 17 hrs ago | 0x55e66f5b3cf90cc707e8945428a7f675224042bb | IN | Create: Manager | 0 AVAX | 0.0652668775 |
[ Download CSV Export ]
Contract Name:
Manager
Compiler Version
v0.8.11+commit.d7f03943
Contract Source Code (Solidity)
/** *Submitted for verification at snowtrace.io on 2022-10-11 */ // SPDX-License-Identifier: MIT // File: @openzeppelin/contracts/security/ReentrancyGuard.sol // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @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]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @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 making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @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 * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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 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 `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount ) external returns (bool); } // File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; /** * @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 IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @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. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @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 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. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/security/Pausable.sol // OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { _requireNotPaused(); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { _requirePaused(); _; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { require(!paused(), "Pausable: paused"); } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { require(paused(), "Pausable: not paused"); } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } // File: contracts/CrowdSale.sol pragma solidity ^0.8.0; contract Crowdsale is Context, ReentrancyGuard { using SafeERC20 for IERC20; // The token being sold IERC20 private _token; IERC20 public USDT; // Address where funds are collected address payable private _wallet; address payable public _manager; uint256 public minBuy = 150 ether; uint256 public maxBuy = 5000 ether; uint256 public sale_price = 0.043 ether; // Amount of wei raised uint256 public _weiRaised; uint256 public _tokenPurchased; bool public success; bool public finalized; bool public _buyable; event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); mapping (address => uint256) public purchase; mapping (address => uint256) public claimed; mapping (address => uint256) public msgValue; uint256 current = block.timestamp * 1 seconds; uint256 public immutable buyTime; // 60 days uint256 public immutable limitationtime ; // 180 days uint256 public immutable claimeTime; // 150 days constructor (uint256 buyTime_, uint256 lockTime, uint256 claimTime_, address payable manager_, IERC20 token_, address payable wallet_) { require(address(token_) != address(0), "Crowdsale: token is the zero address"); _manager = manager_; _token = token_; _wallet = wallet_; buyTime = block.timestamp + buyTime_ * 1 seconds; limitationtime = block.timestamp + (buyTime_ + lockTime) * 1 seconds; claimeTime = block.timestamp + (buyTime_ + lockTime + claimTime_) * 1 seconds; USDT = IERC20(0xc7198437980c041c805A1EDcbA50c1Ce5db95118); // USDT address on Avalanche C chain } /** * @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. */ receive () external payable { } /** * @return the token being sold. */ function token() public view returns (IERC20) { return _token; } /** * @return the address where funds are collected. */ function wallet() public view returns (address payable) { return _wallet; } function getPrice() public view returns(uint256){ return (10**18) / sale_price; } /** * @return the amount of wei raised. */ function weiRaised() public view returns (uint256) { return _weiRaised; } function buyable()public returns(bool) { if(buyTime > block.timestamp){ _buyable = true; } return _buyable; } function buyTokens(uint256 amount) public nonReentrant { require(buyTime > block.timestamp, "Buy Time expired"); require(amount >= minBuy && amount <= maxBuy,"Wrong amount range."); uint256 one = 1 ether; uint256 tokens = (one * amount) / sale_price; require(_token.balanceOf(address(this)) >= tokens, "buy amount exceeds not enough Tokens remaining"); USDT.safeTransferFrom(_msgSender(), address(this), amount); _tokenPurchased = _tokenPurchased + tokens; _weiRaised = _weiRaised + amount; msgValue[_msgSender()] = msgValue[_msgSender()] + amount; purchase[_msgSender()] = purchase[_msgSender()] + tokens; } function pendingTokens(address account) public view returns (uint256) { uint value; if (block.timestamp < limitationtime) value = 0; else if (block.timestamp >= claimeTime) { value = purchase[account] - claimed[account]; } else { uint initValue = purchase[account] / 5; uint remainValue = purchase[account] - initValue; value = initValue; value += remainValue * (block.timestamp - limitationtime) / (claimeTime - limitationtime); value -= claimed[account]; } return value; } function claim() public nonReentrant { require (block.timestamp > limitationtime); require (finalized,"IDO not finalized yet"); uint256 tokenAmount = pendingTokens(_msgSender()); require (tokenAmount > 0, "0 tokens to claim"); require(_token.balanceOf(address(this)) >= tokenAmount, "claim amount exceeds not enough Tokens remaining"); _token.safeTransfer(_msgSender(), tokenAmount); claimed[_msgSender()] += tokenAmount; } function balance() public view returns(uint){ return _token.balanceOf(address(this)); } function finalize() public nonReentrant { require( buyTime < block.timestamp, "the crowdSale is in progress"); require(!finalized,"already finalized"); require(_msgSender() == _manager,"you are not the owner"); uint256 remainingTokensInTheContract = _token.balanceOf(address(this)) - _tokenPurchased; _token.safeTransfer(address(_wallet), remainingTokensInTheContract); _forwardFunds(_weiRaised); finalized = true; } /** * @dev Determines how ETH is stored/forwarded on purchases. */ function _forwardFunds(uint256 amount) internal { USDT.safeTransfer(_wallet, amount); } } // File: @openzeppelin/contracts/token/ERC20/ERC20.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; /** * @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 {ERC20PresetMinterPauser}. * * 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 Contracts guidelines: functions revert * instead 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 ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, 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}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, 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}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); 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) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + 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) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * This 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: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; } _balances[to] += amount; emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(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); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be 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 {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: contracts/Manager.sol pragma solidity ^0.8.0; interface ILASM { function excludeFromDividends(address account) external; function excludeFromFees(address account, bool excluded) external; } contract Manager is Context, Ownable, ReentrancyGuard { using SafeERC20 for IERC20; ILASM token; address public ico_addr; address[] public rounds; uint256[] public roundAmount; event CreateTokenSale(uint256 locktime, uint256 amount, uint256 noRounds); event WithdrawToken(address recipient, uint256 amountToken); constructor(address token_) { token = ILASM(token_); } receive() external payable {} function noRounds() public view returns (uint256) { return rounds.length; } function setToken(address token_) public onlyOwner { token = ILASM(token_); } function getToken() public view returns (address) { return address(token); } function transfer(address recipient, uint256 amount) public payable virtual onlyOwner returns (bool) { require(amount <= IERC20(address(token)).balanceOf(address(this)), "not enough amount"); IERC20(address(token)).safeTransfer(recipient, amount); return true; } function create_TokenSale( uint256 buyTime, uint256 lockTime, uint256 claimTime, uint256 amount ) public onlyOwner { require(getToken() != address(0), "set Token for Sale"); if (rounds.length > 0) { bool status = isSaleFinalized(); require(status == true, "Sale in progress"); } require(amount <= IERC20(address(token)).balanceOf(address(this)), "not enough amount"); Crowdsale ico; ico = new Crowdsale( buyTime, lockTime, claimTime, payable(owner()), IERC20(address(token)), payable(owner()) ); ico_addr = address(ico); token.excludeFromDividends(ico_addr); token.excludeFromFees(ico_addr, true); require(transfer(ico_addr, amount)); rounds.push(ico_addr); roundAmount.push(amount); emit CreateTokenSale(lockTime, amount, rounds.length); } function totalRoundSaleInfo() public view returns (uint256, uint256, uint256) { uint256 length = rounds.length; uint256 totalAmountToken; uint256 totalAmountPurchased; uint256 totalAmountFunds; for (uint8 i=0; i<length; i++) { (uint256 amountToken, uint256 amountPurchased, uint256 amountFunds) = roundSaleInfo(i); totalAmountToken += amountToken; totalAmountPurchased += amountPurchased; totalAmountFunds += amountFunds; } return (totalAmountToken, totalAmountPurchased, totalAmountFunds); } function roundSaleInfo(uint8 index) public view returns (uint256, uint256, uint256) { require(index < rounds.length, "Wrong Round Index."); uint256 amountToken; uint256 amountPurchased; uint256 amountFunds; amountToken += roundAmount[index]; address sale_addr = rounds[index]; Crowdsale sale = Crowdsale(payable(sale_addr)); amountPurchased += sale._tokenPurchased(); amountFunds += sale._weiRaised(); return (amountToken, amountPurchased, amountFunds); } function isSaleFinalized() public view returns (bool) { require(rounds.length > 0, "No round"); address sale_addr = rounds[rounds.length - 1]; Crowdsale sale = Crowdsale(payable(sale_addr)); return sale.finalized(); } function withdrawToken() public onlyOwner { uint256 remainingTokensInTheContract = IERC20(address(token)).balanceOf(address(this)); IERC20(address(token)).safeTransfer(msg.sender, remainingTokensInTheContract); emit WithdrawToken(msg.sender, remainingTokensInTheContract); } }
[{"inputs":[{"internalType":"address","name":"token_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"locktime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"noRounds","type":"uint256"}],"name":"CreateTokenSale","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountToken","type":"uint256"}],"name":"WithdrawToken","type":"event"},{"inputs":[{"internalType":"uint256","name":"buyTime","type":"uint256"},{"internalType":"uint256","name":"lockTime","type":"uint256"},{"internalType":"uint256","name":"claimTime","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"create_TokenSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ico_addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSaleFinalized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"noRounds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"roundAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"index","type":"uint8"}],"name":"roundSaleInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rounds","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalRoundSaleInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"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":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000009c0c0e21a8a4787e3304f93767695101217de113
-----Decoded View---------------
Arg [0] : token_ (address): 0x9c0c0e21a8a4787e3304f93767695101217de113
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000009c0c0e21a8a4787e3304f93767695101217de113
Deployed ByteCode Sourcemap
46886:3918:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47455:91;;;;;;;;;;-1:-1:-1;47455:91:0;;;;;:::i;:::-;;:::i;:::-;;47554:90;;;;;;;;;;-1:-1:-1;47630:5:0;;-1:-1:-1;;;;;47630:5:0;47554:90;;;-1:-1:-1;;;;;547:32:1;;;529:51;;517:2;502:18;47554:90:0;;;;;;;;47358:89;;;;;;;;;;-1:-1:-1;47426:6:0;:13;47358:89;;;737:25:1;;;725:2;710:18;47358:89:0;591:177:1;47060:28:0;;;;;;;;;;-1:-1:-1;47060:28:0;;;;;:::i;:::-;;:::i;45836:103::-;;;;;;;;;;;;;:::i;49659:556::-;;;;;;;;;;-1:-1:-1;49659:556:0;;;;;:::i;:::-;;:::i;:::-;;;;1434:25:1;;;1490:2;1475:18;;1468:34;;;;1518:18;;;1511:34;1422:2;1407:18;49659:556:0;1232:319:1;50223:262:0;;;;;;;;;;;;;:::i;:::-;;;1721:14:1;;1714:22;1696:41;;1684:2;1669:18;50223:262:0;1556:187:1;47030:23:0;;;;;;;;;;-1:-1:-1;47030:23:0;;;;;:::i;:::-;;:::i;45188:87::-;;;;;;;;;;-1:-1:-1;45234:7:0;45261:6;-1:-1:-1;;;;;45261:6:0;45188:87;;47652:339;;;;;;:::i;:::-;;:::i;47999:1030::-;;;;;;;;;;-1:-1:-1;47999:1030:0;;;;;:::i;:::-;;:::i;47000:23::-;;;;;;;;;;-1:-1:-1;47000:23:0;;;;-1:-1:-1;;;;;47000:23:0;;;50493:308;;;;;;;;;;;;;:::i;49037:614::-;;;;;;;;;;;;;:::i;46094:201::-;;;;;;;;;;-1:-1:-1;46094:201:0;;;;;:::i;:::-;;:::i;47455:91::-;45074:13;:11;:13::i;:::-;47517:5:::1;:21:::0;;-1:-1:-1;;;;;;47517:21:0::1;-1:-1:-1::0;;;;;47517:21:0;;;::::1;::::0;;;::::1;::::0;;47455:91::o;47060:28::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47060:28:0;:::o;45836:103::-;45074:13;:11;:13::i;:::-;45901:30:::1;45928:1;45901:18;:30::i;:::-;45836:103::o:0;49659:556::-;49716:7;49725;49734;49770:6;:13;;;;49762:5;:21;;;49754:52;;;;-1:-1:-1;;;49754:52:0;;2599:2:1;49754:52:0;;;2581:21:1;2638:2;2618:18;;;2611:30;-1:-1:-1;;;2657:18:1;;;2650:48;2715:18;;49754:52:0;;;;;;;;;49817:19;49847:23;49881:19;49928:11;49940:5;49928:18;;;;;;;;;;:::i;:::-;;;;;;;;;49913:33;;;;;:::i;:::-;;;49959:17;49979:6;49986:5;49979:13;;;;;;;;;;:::i;:::-;;;;;;;;;;;;50079:22;;;-1:-1:-1;;;50079:22:0;;;;-1:-1:-1;;;;;49979:13:0;;;;-1:-1:-1;49979:13:0;;;;50079:20;;:22;;;;;49979:13;50079:22;;;;;;49979:13;50079:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50060:41;;;;:::i;:::-;;;50127:4;-1:-1:-1;;;;;50127:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50112:32;;;;:::i;:::-;50165:11;;50178:15;;-1:-1:-1;50165:11:0;;-1:-1:-1;49659:556:0;;-1:-1:-1;;;;;49659:556:0:o;50223:262::-;50296:6;:13;50271:4;;50288:38;;;;-1:-1:-1;;;50288:38:0;;3532:2:1;50288:38:0;;;3514:21:1;3571:1;3551:18;;;3544:29;-1:-1:-1;;;3589:18:1;;;3582:38;3637:18;;50288:38:0;3330:331:1;50288:38:0;50359:6;50366:13;;50339:17;;50359:6;50366:17;;50382:1;;50366:17;:::i;:::-;50359:25;;;;;;;;:::i;:::-;;;;;;;;;;;;50461:16;;;-1:-1:-1;;;50461:16:0;;;;-1:-1:-1;;;;;50359:25:0;;;;-1:-1:-1;50359:25:0;;;;50461:14;;:16;;;;;50359:25;50461:16;;;;;;50359:25;50461:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50454:23;;;;50223:262;:::o;47030:23::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;47030:23:0;;-1:-1:-1;47030:23:0;:::o;47652:339::-;47792:4;45074:13;:11;:13::i;:::-;47842:5:::1;::::0;47827:47:::1;::::0;-1:-1:-1;;;47827:47:0;;47868:4:::1;47827:47;::::0;::::1;529:51:1::0;-1:-1:-1;;;;;47842:5:0;;::::1;::::0;47827:32:::1;::::0;502:18:1;;47827:47:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47817:6;:57;;47809:87;;;::::0;-1:-1:-1;;;47809:87:0;;4280:2:1;47809:87:0::1;::::0;::::1;4262:21:1::0;4319:2;4299:18;;;4292:30;-1:-1:-1;;;4338:18:1;;;4331:47;4395:18;;47809:87:0::1;4078:341:1::0;47809:87:0::1;47922:5;::::0;47907:54:::1;::::0;-1:-1:-1;;;;;47922:5:0::1;47943:9:::0;47954:6;47907:35:::1;:54::i;:::-;-1:-1:-1::0;47979:4:0::1;47652:339:::0;;;;:::o;47999:1030::-;45074:13;:11;:13::i;:::-;48196:1:::1;48174:10;47630:5:::0;;-1:-1:-1;;;;;47630:5:0;;47554:90;48174:10:::1;-1:-1:-1::0;;;;;48174:24:0::1;;;48166:55;;;::::0;-1:-1:-1;;;48166:55:0;;4626:2:1;48166:55:0::1;::::0;::::1;4608:21:1::0;4665:2;4645:18;;;4638:30;-1:-1:-1;;;4684:18:1;;;4677:48;4742:18;;48166:55:0::1;4424:342:1::0;48166:55:0::1;48238:6;:13:::0;:17;48234:139:::1;;48272:11;48286:17;:15;:17::i;:::-;48272:31:::0;-1:-1:-1;48336:4:0::1;48326:14:::0;::::1;;;48318:43;;;::::0;-1:-1:-1;;;48318:43:0;;4973:2:1;48318:43:0::1;::::0;::::1;4955:21:1::0;5012:2;4992:18;;;4985:30;-1:-1:-1;;;5031:18:1;;;5024:46;5087:18;;48318:43:0::1;4771:340:1::0;48318:43:0::1;48257:116;48234:139;48418:5;::::0;48403:47:::1;::::0;-1:-1:-1;;;48403:47:0;;48444:4:::1;48403:47;::::0;::::1;529:51:1::0;-1:-1:-1;;;;;48418:5:0;;::::1;::::0;48403:32:::1;::::0;502:18:1;;48403:47:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48393:6;:57;;48385:87;;;::::0;-1:-1:-1;;;48385:87:0;;4280:2:1;48385:87:0::1;::::0;::::1;4262:21:1::0;4319:2;4299:18;;;4292:30;-1:-1:-1;;;4338:18:1;;;4331:47;4395:18;;48385:87:0::1;4078:341:1::0;48385:87:0::1;48485:13;48543:7;48565:8;48588:9;48620:7;45234::::0;45261:6;-1:-1:-1;;;;;45261:6:0;;45188:87;48620:7:::1;48658:5;::::0;-1:-1:-1;;;;;48658:5:0::1;48688:7;45234::::0;45261:6;-1:-1:-1;;;;;45261:6:0;;45188:87;48688:7:::1;48515:192;;;;;:::i;:::-;5449:25:1::0;;;5505:2;5490:18;;5483:34;;;;5548:2;5533:18;;5526:34;;;;-1:-1:-1;;;;;5634:15:1;;;5629:2;5614:18;;5607:43;5687:15;;;5681:3;5666:19;;5659:44;5740:15;5587:3;5719:19;;5712:44;5436:3;5421:19;48515:192:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;48718:8:0::1;:23:::0;;-1:-1:-1;;;;;;48718:23:0::1;-1:-1:-1::0;;;;;48718:23:0;;::::1;::::0;;::::1;::::0;;;48754:5:::1;::::0;:36:::1;::::0;-1:-1:-1;;;48754:36:0;;::::1;::::0;::::1;529:51:1::0;;;;48718:23:0;;-1:-1:-1;48754:5:0;::::1;::::0;:26:::1;::::0;502:18:1;;48754:36:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;48801:5:0::1;::::0;48823:8:::1;::::0;48801:37:::1;::::0;-1:-1:-1;;;48801:37:0;;-1:-1:-1;;;;;48823:8:0;;::::1;48801:37;::::0;::::1;5935:51:1::0;48801:5:0;6002:18:1;;;5995:50;48801:5:0;::::1;::::0;-1:-1:-1;48801:21:0::1;::::0;-1:-1:-1;5908:18:1;;48801:37:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;48868:8:0::1;::::0;48859:26:::1;::::0;-1:-1:-1;;;;;;48868:8:0::1;::::0;-1:-1:-1;48878:6:0;48859:8:::1;:26::i;:::-;48851:35;;;::::0;::::1;;48911:8;::::0;48899:6:::1;:21:::0;;48911:8;48899:21;;::::1;::::0;;;;;::::1;::::0;;-1:-1:-1;;;;;;48899:21:0::1;-1:-1:-1::0;;;;;48911:8:0;;::::1;48899:21:::0;;;::::1;::::0;;;48931:11:::1;:24:::0;;;;::::1;::::0;;-1:-1:-1;48931:24:0;;;;::::1;::::0;;;49007:13;48973:48:::1;::::0;;1434:25:1;;;1490:2;1475:18;;1468:34;;;1518:18;;;1511:34;;;;48973:48:0::1;::::0;1422:2:1;1407:18;48973:48:0::1;;;;;;;48155:874;47999:1030:::0;;;;:::o;50493:308::-;45074:13;:11;:13::i;:::-;50600:5:::1;::::0;50585:47:::1;::::0;-1:-1:-1;;;50585:47:0;;50626:4:::1;50585:47;::::0;::::1;529:51:1::0;50546:36:0::1;::::0;-1:-1:-1;;;;;50600:5:0::1;::::0;50585:32:::1;::::0;502:18:1;;50585:47:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50658:5;::::0;50546:86;;-1:-1:-1;50643:77:0::1;::::0;-1:-1:-1;;;;;50658:5:0::1;50679:10;50546:86:::0;50643:35:::1;:77::i;:::-;50738:55;::::0;;50752:10:::1;6230:51:1::0;;6312:2;6297:18;;6290:34;;;50738:55:0::1;::::0;6203:18:1;50738:55:0::1;;;;;;;50535:266;50493:308::o:0;49037:614::-;49143:6;:13;49088:7;;;;;;;;;;49276:290;49294:6;49292:1;:8;;;49276:290;;;49323:19;49344:23;49369:19;49392:16;49406:1;49392:13;:16::i;:::-;49322:86;;-1:-1:-1;49322:86:0;-1:-1:-1;49322:86:0;-1:-1:-1;49423:31:0;49322:86;49423:31;;:::i;:::-;;-1:-1:-1;49469:39:0;49493:15;49469:39;;:::i;:::-;;-1:-1:-1;49523:31:0;49543:11;49523:31;;:::i;:::-;;;49307:259;;;49302:3;;;;;:::i;:::-;;;;49276:290;;;-1:-1:-1;49586:16:0;;49604:20;;-1:-1:-1;49626:16:0;;-1:-1:-1;49037:614:0;-1:-1:-1;;49037:614:0:o;46094:201::-;45074:13;:11;:13::i;:::-;-1:-1:-1;;;;;46183:22:0;::::1;46175:73;;;::::0;-1:-1:-1;;;46175:73:0;;6717:2:1;46175:73:0::1;::::0;::::1;6699:21:1::0;6756:2;6736:18;;;6729:30;6795:34;6775:18;;;6768:62;-1:-1:-1;;;6846:18:1;;;6839:36;6892:19;;46175:73:0::1;6515:402:1::0;46175:73:0::1;46259:28;46278:8;46259:18;:28::i;:::-;46094:201:::0;:::o;45353:132::-;45234:7;45261:6;-1:-1:-1;;;;;45261:6:0;22589:10;45417:23;45409:68;;;;-1:-1:-1;;;45409:68:0;;7124:2:1;45409:68:0;;;7106:21:1;;;7143:18;;;7136:30;7202:34;7182:18;;;7175:62;7254:18;;45409:68:0;6922:356:1;46455:191:0;46529:16;46548:6;;-1:-1:-1;;;;;46565:17:0;;;-1:-1:-1;;;;;;46565:17:0;;;;;;46598:40;;46548:6;;;;;;;46598:40;;46529:16;46598:40;46518:128;46455:191;:::o;18040:211::-;18184:58;;;-1:-1:-1;;;;;6248:32:1;;18184:58:0;;;6230:51:1;6297:18;;;;6290:34;;;18184:58:0;;;;;;;;;;6203:18:1;;;;18184:58:0;;;;;;;;-1:-1:-1;;;;;18184:58:0;-1:-1:-1;;;18184:58:0;;;18157:86;;18177:5;;18157:19;:86::i;:::-;18040:211;;;:::o;21107:716::-;21531:23;21557:69;21585:4;21557:69;;;;;;;;;;;;;;;;;21565:5;-1:-1:-1;;;;;21557:27:0;;;:69;;;;;:::i;:::-;21641:17;;21531:95;;-1:-1:-1;21641:21:0;21637:179;;21738:10;21727:30;;;;;;;;;;;;:::i;:::-;21719:85;;;;-1:-1:-1;;;21719:85:0;;7485:2:1;21719:85:0;;;7467:21:1;7524:2;7504:18;;;7497:30;7563:34;7543:18;;;7536:62;-1:-1:-1;;;7614:18:1;;;7607:40;7664:19;;21719:85:0;7283:406:1;6772:229:0;6909:12;6941:52;6963:6;6971:4;6977:1;6980:12;6941:21;:52::i;:::-;6934:59;;6772:229;;;;;;:::o;7892:510::-;8062:12;8120:5;8095:21;:30;;8087:81;;;;-1:-1:-1;;;8087:81:0;;7896:2:1;8087:81:0;;;7878:21:1;7935:2;7915:18;;;7908:30;7974:34;7954:18;;;7947:62;-1:-1:-1;;;8025:18:1;;;8018:36;8071:19;;8087:81:0;7694:402:1;8087:81:0;-1:-1:-1;;;;;4322:19:0;;;8179:60;;;;-1:-1:-1;;;8179:60:0;;8303:2:1;8179:60:0;;;8285:21:1;8342:2;8322:18;;;8315:30;8381:31;8361:18;;;8354:59;8430:18;;8179:60:0;8101:353:1;8179:60:0;8253:12;8267:23;8294:6;-1:-1:-1;;;;;8294:11:0;8313:5;8320:4;8294:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8252:73;;;;8343:51;8360:7;8369:10;8381:12;8343:16;:51::i;:::-;8336:58;7892:510;-1:-1:-1;;;;;;;7892:510:0:o;10578:762::-;10728:12;10757:7;10753:580;;;-1:-1:-1;10788:10:0;10781:17;;10753:580;10902:17;;:21;10898:424;;11150:10;11144:17;11211:15;11198:10;11194:2;11190:19;11183:44;10898:424;11293:12;11286:20;;-1:-1:-1;;;11286:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;773:180::-;832:6;885:2;873:9;864:7;860:23;856:32;853:52;;;901:1;898;891:12;853:52;-1:-1:-1;924:23:1;;773:180;-1:-1:-1;773:180:1:o;958:269::-;1015:6;1068:2;1056:9;1047:7;1043:23;1039:32;1036:52;;;1084:1;1081;1074:12;1036:52;1123:9;1110:23;1173:4;1166:5;1162:16;1155:5;1152:27;1142:55;;1193:1;1190;1183:12;1748:254;1816:6;1824;1877:2;1865:9;1856:7;1852:23;1848:32;1845:52;;;1893:1;1890;1883:12;1845:52;1916:29;1935:9;1916:29;:::i;:::-;1906:39;1992:2;1977:18;;;;1964:32;;-1:-1:-1;;;1748:254:1:o;2007:385::-;2093:6;2101;2109;2117;2170:3;2158:9;2149:7;2145:23;2141:33;2138:53;;;2187:1;2184;2177:12;2138:53;-1:-1:-1;;2210:23:1;;;2280:2;2265:18;;2252:32;;-1:-1:-1;2331:2:1;2316:18;;2303:32;;2382:2;2367:18;2354:32;;-1:-1:-1;2007:385:1;-1:-1:-1;2007:385:1:o;2744:127::-;2805:10;2800:3;2796:20;2793:1;2786:31;2836:4;2833:1;2826:15;2860:4;2857:1;2850:15;2876:127;2937:10;2932:3;2928:20;2925:1;2918:31;2968:4;2965:1;2958:15;2992:4;2989:1;2982:15;3008:128;3048:3;3079:1;3075:6;3072:1;3069:13;3066:39;;;3085:18;;:::i;:::-;-1:-1:-1;3121:9:1;;3008:128::o;3141:184::-;3211:6;3264:2;3252:9;3243:7;3239:23;3235:32;3232:52;;;3280:1;3277;3270:12;3232:52;-1:-1:-1;3303:16:1;;3141:184;-1:-1:-1;3141:184:1:o;3666:125::-;3706:4;3734:1;3731;3728:8;3725:34;;;3739:18;;:::i;:::-;-1:-1:-1;3776:9:1;;3666:125::o;3796:277::-;3863:6;3916:2;3904:9;3895:7;3891:23;3887:32;3884:52;;;3932:1;3929;3922:12;3884:52;3964:9;3958:16;4017:5;4010:13;4003:21;3996:5;3993:32;3983:60;;4039:1;4036;4029:12;6335:175;6372:3;6416:4;6409:5;6405:16;6445:4;6436:7;6433:17;6430:43;;;6453:18;;:::i;:::-;6502:1;6489:15;;6335:175;-1:-1:-1;;6335:175:1:o;8459:258::-;8531:1;8541:113;8555:6;8552:1;8549:13;8541:113;;;8631:11;;;8625:18;8612:11;;;8605:39;8577:2;8570:10;8541:113;;;8672:6;8669:1;8666:13;8663:48;;;8707:1;8698:6;8693:3;8689:16;8682:27;8663:48;;8459:258;;;:::o;8722:274::-;8851:3;8889:6;8883:13;8905:53;8951:6;8946:3;8939:4;8931:6;8927:17;8905:53;:::i;:::-;8974:16;;;;;8722:274;-1:-1:-1;;8722:274:1:o;9001:383::-;9150:2;9139:9;9132:21;9113:4;9182:6;9176:13;9225:6;9220:2;9209:9;9205:18;9198:34;9241:66;9300:6;9295:2;9284:9;9280:18;9275:2;9267:6;9263:15;9241:66;:::i;:::-;9368:2;9347:15;-1:-1:-1;;9343:29:1;9328:45;;;;9375:2;9324:54;;9001:383;-1:-1:-1;;9001:383:1:o
Swarm Source
ipfs://f9bb825fc07174ba09eac268585038be1ad95f0ff2f0a9eb7a90cbdee47cf8fb
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.