Contract 0x9B5EC2ddCb1BeeBEA5FFe94e6449b4eC56294cBa 7

 
Txn Hash Method
Block
From
To
Value
0x67a03e7337cacd76cdfa5512aeb3221ee22469620ebd59d16b48539161f8641cTransfer Ownersh...32990772023-08-30 9:25:01229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000381604050.357666318
0xdf687b8806241b31433663a77df63b2863dcb989357eb2d12487703d3ae208b4Mint For32990732023-08-30 9:24:53229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0001874057360.357666318
0x7a692ee560e9ee6cfa3eff73162743b08e0d80431c97ac0fb67d52f9dc90df4cMint For32990702023-08-30 9:24:47229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0001996050960.357666318
0xf391a8d940281a7095bb23950ed31fbee8eeff7b9e098856bf6920ce8834e872Mint For32990662023-08-30 9:24:39229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0002172743790.357666318
0x33134be9b09b6bc13171a28c6206f7f28f6d722cc725743113914deb5112f4a5Mint For32990622023-08-30 9:24:31229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0001922327720.357666318
0x8c98463c416c5130d5fbcf2baf6ee6761e9beb2a52fc86cf09ae78e2dc3f124cMint For32990592023-08-30 9:24:25229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0002008075480.357666318
0x4d1eea6ef0d24b349ce5fa32280535d8247452148dd7b74882012e59874a804fMint For32990552023-08-30 9:24:17229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0001919077370.357666318
0xa809a78dec2f246ad7d361995241ecfc31b52d71dfe58682347daad371293be3Mint For32990512023-08-30 9:24:09229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0002011990350.357666318
0x0f797e850535e2674f35d7df890edf5080ec1b19d4f9a64a595d65d23a2d5e4fMint For32990472023-08-30 9:24:01229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0002010863070.357666318
0xc7e50e9f8db3fc390fd1e97413c3896001559187faa33340dde63bc1a40dc590Mint For32990442023-08-30 9:23:55229 days 19 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0001921864960.357666318
0x26b05124d775ac811f764c75d5db95a40adc7c55327d726500dd2e8924795cc8Transfer Ownersh...30045442023-08-23 13:47:15236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000418799210.00000013
0x465d4dec435cc22207f954ad59723662b64a038a66f6aa09a7a9a5a71f7c6f28Mint For30045382023-08-23 13:47:03236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000514021950.00000013
0x50527be9029a5cb2dc6cc1914709a14d721ae9bed192d9878d4c770bc5083421Mint For30045332023-08-23 13:46:53236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000511754210.00000013
0x5cb87647e39c72734d306c4642634dce44dbe713f2ffbcfcfe12a97c5b965b80Mint For30045222023-08-23 13:46:31236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000481310940.00000013
0xe8876e38ea2311c4430a0699083bdfcf212f061ef83f8965bcb6de336326090cMint For30045142023-08-23 13:46:15236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000466606090.00000013
0x7815928f2483c9dd7a56a4daf16b2d37384e5f518f75fc76c9ab97eae1aac632Mint For30044952023-08-23 13:45:37236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000442362960.00000013
0xf1e622d84a9b8503861b6b456c19023f4143db181cfb6fb736bc2a022c393398Mint For30044912023-08-23 13:45:29236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000440411360.00000013
0x6da95b596267f5f85199bb91c76b918d430ca3161b89332efbdf691af0922f0fMint For30044882023-08-23 13:45:23236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000440411340.00000013
0x3086441debe2bc0f4fe93286e92521949ce5c8190c78c82d06f05a2123f37eddMint For30044842023-08-23 13:45:15236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000432757270.00000013
0x7bda0837edf1ff896dc7df005f57c2042c9b545536c2420fefc9db21494e4239Mint For30044812023-08-23 13:45:09236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000430839590.00000013
0x66386506936d5d30ae1fe9e156d6ca996d15f6a4e76870e9fbabf6dd2bd5fe48Mint For30044772023-08-23 13:45:01236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000442584450.00000013
0x2b251c5307a3d26017e1c565cff261419820a0c88e6efc45250a44cd65aff4cfMint For30044732023-08-23 13:44:53236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000454422140.00000013
0x37f4b115780e4225b2b8ca391248f9f16377c2c95533ee682d825996d0e6de8aMint For30044702023-08-23 13:44:47236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000461266910.00000013
0x7c68d859c191b9e7eec81721991b8c1d0196946d626ed6d1b19bf0a82ef61ffeMint For30044662023-08-23 13:44:39236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.000045922290.00000013
0xe05184743652a45c84b7d76aa33b6878fe6ee015c095e28e060be5ab1de8066cMint For30044622023-08-23 13:44:31236 days 14 hrs ago0x3b91ca4d89b5156d456cbd0d6305f7f36b1517a4 IN  0x9b5ec2ddcb1beebea5ffe94e6449b4ec56294cba0 ETH0.0000461266930.00000013
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MintTank

Compiler Version
v0.8.13+commit.abaa5c0e

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, GNU AGPLv3 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at basescan.org on 2023-08-13
*/

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/utils/SafeERC20.sol)




// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)



/**
 * @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);
}


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)



/**
 * @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);
}


// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)



/**
 * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/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.8.0/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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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);
        }
    }
}


/**
 * @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;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    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));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    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");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Compatible with tokens that require the approval to be set to
     * 0 before setting it to a non-zero value.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation 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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}


// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)




// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)



/**
 * @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;
    }
}


/**
 * @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. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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);
    }
}

interface IFlow {
    function totalSupply() external view returns (uint);
    function balanceOf(address) external view returns (uint);
    function approve(address spender, uint value) external returns (bool);
    function transfer(address, uint) external returns (bool);
    function transferFrom(address,address,uint) external returns (bool);
    function mint(address, uint) external returns (bool);
    function minter() external returns (address);
}



interface IVotingEscrow {

    struct Point {
        int128 bias;
        int128 slope; // # -dweight / dt
        uint256 ts;
        uint256 blk; // block
    }

    function token() external view returns (address);
    function team() external returns (address);
    function epoch() external view returns (uint);
    function point_history(uint loc) external view returns (Point memory);
    function user_point_history(uint tokenId, uint loc) external view returns (Point memory);
    function user_point_epoch(uint tokenId) external view returns (uint);

    function ownerOf(uint) external view returns (address);
    function isApprovedOrOwner(address, uint) external view returns (bool);
    function transferFrom(address, address, uint) external;

    function voting(uint tokenId) external;
    function abstain(uint tokenId) external;
    function attach(uint tokenId) external;
    function detach(uint tokenId) external;

    function checkpoint() external;
    function deposit_for(uint tokenId, uint value) external;
    function create_lock_for(uint, uint, address) external returns (uint);

    function balanceOfNFT(uint) external view returns (uint);
    function totalSupply() external view returns (uint);
}

/**
 * @dev This contract allow the team to hold a large amount of FLOW but not pre lock them.
 * It requires that FLOW exiting this be locked for more than 90days.
 */
contract MintTank is Ownable {
    address public immutable FLOW;
    address public immutable votingEscrow;
    uint256 public immutable minLockTime;

    constructor(
        address _flow,
        address _votingEscrow,
        address _team,
        uint256 _minLockTime
    ) {
        FLOW = _flow;
        votingEscrow = _votingEscrow;
        minLockTime = _minLockTime;
        _transferOwnership(_team);
    }

    /**
     * @dev Mints a new NFT to an address designated with a minimum of a 90day lock
     */
    function mintFor(
        uint _value,
        uint _lock_duration,
        address _to
    ) public onlyOwner {
        require(_lock_duration >= minLockTime, "Check minLockTime");
        IFlow(FLOW).approve(votingEscrow, _value);
        IVotingEscrow(votingEscrow).create_lock_for(
            _value,
            _lock_duration,
            _to
        );
    }

    /**
     * @dev Allows owner to clean out the contract of ANY tokens including v2, but not v1
     */
    function inCaseTokensGetStuck(
        address _token,
        address _to,
        uint256 _amount
    ) public onlyOwner {
        require(_token != address(FLOW), "FLOW must be minted to get it out");
        SafeERC20.safeTransfer(IERC20(_token), _to, _amount);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_flow","type":"address"},{"internalType":"address","name":"_votingEscrow","type":"address"},{"internalType":"address","name":"_team","type":"address"},{"internalType":"uint256","name":"_minLockTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"FLOW","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"inCaseTokensGetStuck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minLockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"uint256","name":"_lock_duration","type":"uint256"},{"internalType":"address","name":"_to","type":"address"}],"name":"mintFor","outputs":[],"stateMutability":"nonpayable","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":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"votingEscrow","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

Deployed Bytecode

0x608060405234801561001057600080fd5b50600436106100885760003560e01c80638da5cb5b1161005b5780638da5cb5b14610115578063a60ff76614610126578063f2fde38b1461015b578063f587268a1461016e57600080fd5b80633189097b1461008d5780634f2bfe5b146100d1578063715018a6146100f857806382a09b3014610102575b600080fd5b6100b47f000000000000000000000000d386a121991e51eab5e3433bf5b1cf4c8884b47a81565b6040516001600160a01b0390911681526020015b60405180910390f35b6100b47f00000000000000000000000091f85d68b413de823684c891db515b0390a0251281565b610100610181565b005b6101006101103660046107dc565b610195565b6000546001600160a01b03166100b4565b61014d7f0000000000000000000000000000000000000000000000000000000001dfe20081565b6040519081526020016100c8565b610100610169366004610811565b61035a565b61010061017c366004610833565b6103d3565b610189610476565b61019360006104d0565b565b61019d610476565b7f0000000000000000000000000000000000000000000000000000000001dfe2008210156102065760405162461bcd60e51b8152602060048201526011602482015270436865636b206d696e4c6f636b54696d6560781b60448201526064015b60405180910390fd5b60405163095ea7b360e01b81526001600160a01b037f00000000000000000000000091f85d68b413de823684c891db515b0390a0251281166004830152602482018590527f000000000000000000000000d386a121991e51eab5e3433bf5b1cf4c8884b47a169063095ea7b3906044016020604051808303816000875af1158015610295573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906102b9919061086f565b5060405163d4e54c3b60e01b815260048101849052602481018390526001600160a01b0382811660448301527f00000000000000000000000091f85d68b413de823684c891db515b0390a02512169063d4e54c3b906064016020604051808303816000875af1158015610330573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103549190610891565b50505050565b610362610476565b6001600160a01b0381166103c75760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016101fd565b6103d0816104d0565b50565b6103db610476565b7f000000000000000000000000d386a121991e51eab5e3433bf5b1cf4c8884b47a6001600160a01b0316836001600160a01b0316036104665760405162461bcd60e51b815260206004820152602160248201527f464c4f57206d757374206265206d696e74656420746f20676574206974206f756044820152601d60fa1b60648201526084016101fd565b610471838383610520565b505050565b6000546001600160a01b031633146101935760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016101fd565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b604080516001600160a01b03848116602483015260448083018590528351808403909101815260649092018352602080830180516001600160e01b031663a9059cbb60e01b17905283518085019094528084527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c656490840152610471928692916000916105b0918516908490610630565b90508051600014806105d15750808060200190518101906105d1919061086f565b6104715760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b60648201526084016101fd565b606061063f8484600085610647565b949350505050565b6060824710156106a85760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b60648201526084016101fd565b600080866001600160a01b031685876040516106c491906108d6565b60006040518083038185875af1925050503d8060008114610701576040519150601f19603f3d011682016040523d82523d6000602084013e610706565b606091505b509150915061071787838387610722565b979650505050505050565b6060831561079157825160000361078a576001600160a01b0385163b61078a5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016101fd565b508161063f565b61063f83838151156107a65781518083602001fd5b8060405162461bcd60e51b81526004016101fd91906108f2565b80356001600160a01b03811681146107d757600080fd5b919050565b6000806000606084860312156107f157600080fd5b8335925060208401359150610808604085016107c0565b90509250925092565b60006020828403121561082357600080fd5b61082c826107c0565b9392505050565b60008060006060848603121561084857600080fd5b610851846107c0565b925061085f602085016107c0565b9150604084013590509250925092565b60006020828403121561088157600080fd5b8151801515811461082c57600080fd5b6000602082840312156108a357600080fd5b5051919050565b60005b838110156108c55781810151838201526020016108ad565b838111156103545750506000910152565b600082516108e88184602087016108aa565b9190910192915050565b60208152600082518060208401526109118160408501602087016108aa565b601f01601f1916919091016040019291505056fea264697066735822122097ae739e56f182aebafc64d6bb1328bb55c22ca59bf9aef89fadeea89bba8eb664736f6c634300080d0033

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000d386a121991e51eab5e3433bf5b1cf4c8884b47a00000000000000000000000091f85d68b413de823684c891db515b0390a02512000000000000000000000000fa89a4c7f79dc4111c116a0f01061f4a7d9fab730000000000000000000000000000000000000000000000000000000001dfe200

-----Decoded View---------------
Arg [0] : _flow (address): 0xd386a121991E51Eab5e3433Bf5B1cF4C8884b47a
Arg [1] : _votingEscrow (address): 0x91F85d68B413dE823684c891db515B0390a02512
Arg [2] : _team (address): 0xfA89A4C7F79Dc4111c116a0f01061F4a7D9fAb73
Arg [3] : _minLockTime (uint256): 31449600

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000d386a121991e51eab5e3433bf5b1cf4c8884b47a
Arg [1] : 00000000000000000000000091f85d68b413de823684c891db515b0390a02512
Arg [2] : 000000000000000000000000fa89a4c7f79dc4111c116a0f01061f4a7d9fab73
Arg [3] : 0000000000000000000000000000000000000000000000000000000001dfe200


Deployed ByteCode Sourcemap

26888:1321:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26924:29;;;;;;;;-1:-1:-1;;;;;178:32:1;;;160:51;;148:2;133:18;26924:29:0;;;;;;;;26960:37;;;;;24161:103;;;:::i;:::-;;27433:378;;;;;;:::i;:::-;;:::i;23520:87::-;23566:7;23593:6;-1:-1:-1;;;;;23593:6:0;23520:87;;27004:36;;;;;;;;873:25:1;;;861:2;846:18;27004:36:0;727:177:1;24419:201:0;;;;;;:::i;:::-;;:::i;27928:278::-;;;;;;:::i;:::-;;:::i;24161:103::-;23406:13;:11;:13::i;:::-;24226:30:::1;24253:1;24226:18;:30::i;:::-;24161:103::o:0;27433:378::-;23406:13;:11;:13::i;:::-;27585:11:::1;27567:14;:29;;27559:59;;;::::0;-1:-1:-1;;;27559:59:0;;1635:2:1;27559:59:0::1;::::0;::::1;1617:21:1::0;1674:2;1654:18;;;1647:30;-1:-1:-1;;;1693:18:1;;;1686:47;1750:18;;27559:59:0::1;;;;;;;;;27629:41;::::0;-1:-1:-1;;;27629:41:0;;-1:-1:-1;;;;;27649:12:0::1;1971:32:1::0;;27629:41:0::1;::::0;::::1;1953:51:1::0;2020:18;;;2013:34;;;27635:4:0::1;27629:19;::::0;::::1;::::0;1926:18:1;;27629:41:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;27681:122:0::1;::::0;-1:-1:-1;;;27681:122:0;;::::1;::::0;::::1;2542:25:1::0;;;2583:18;;;2576:34;;;-1:-1:-1;;;;;2646:32:1;;;2626:18;;;2619:60;27695:12:0::1;27681:43;::::0;::::1;::::0;2515:18:1;;27681:122:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;27433:378:::0;;;:::o;24419:201::-;23406:13;:11;:13::i;:::-;-1:-1:-1;;;;;24508:22:0;::::1;24500:73;;;::::0;-1:-1:-1;;;24500:73:0;;3081:2:1;24500:73:0::1;::::0;::::1;3063:21:1::0;3120:2;3100:18;;;3093:30;3159:34;3139:18;;;3132:62;-1:-1:-1;;;3210:18:1;;;3203:36;3256:19;;24500:73:0::1;2879:402:1::0;24500:73:0::1;24584:28;24603:8;24584:18;:28::i;:::-;24419:201:::0;:::o;27928:278::-;23406:13;:11;:13::i;:::-;28092:4:::1;-1:-1:-1::0;;;;;28074:23:0::1;:6;-1:-1:-1::0;;;;;28074:23:0::1;::::0;28066:69:::1;;;::::0;-1:-1:-1;;;28066:69:0;;3488:2:1;28066:69:0::1;::::0;::::1;3470:21:1::0;3527:2;3507:18;;;3500:30;3566:34;3546:18;;;3539:62;-1:-1:-1;;;3617:18:1;;;3610:31;3658:19;;28066:69:0::1;3286:397:1::0;28066:69:0::1;28146:52;28176:6;28185:3;28190:7;28146:22;:52::i;:::-;27928:278:::0;;;:::o;23685:132::-;23566:7;23593:6;-1:-1:-1;;;;;23593:6:0;22307:10;23749:23;23741:68;;;;-1:-1:-1;;;23741:68:0;;3890:2:1;23741:68:0;;;3872:21:1;;;3909:18;;;3902:30;3968:34;3948:18;;;3941:62;4020:18;;23741:68:0;3688:356:1;24780:191:0;24854:16;24873:6;;-1:-1:-1;;;;;24890:17:0;;;-1:-1:-1;;;;;;24890:17:0;;;;;;24923:40;;24873:6;;;;;;;24923:40;;24854:16;24923:40;24843:128;24780:191;:::o;15455:177::-;15565:58;;;-1:-1:-1;;;;;1971:32:1;;;15565:58:0;;;1953:51:1;2020:18;;;;2013:34;;;15565:58:0;;;;;;;;;;1926:18:1;;;;15565:58:0;;;;;;;;-1:-1:-1;;;;;15565:58:0;-1:-1:-1;;;15565:58:0;;;20228:69;;;;;;;;;;;;;;;;15538:86;;15558:5;;15565:58;-1:-1:-1;;20228:69:0;;:27;;;15565:58;;20228:27;:69::i;:::-;20202:95;;20316:10;:17;20337:1;20316:22;:56;;;;20353:10;20342:30;;;;;;;;;;;;:::i;:::-;20308:111;;;;-1:-1:-1;;;20308:111:0;;4251:2:1;20308:111:0;;;4233:21:1;4290:2;4270:18;;;4263:30;4329:34;4309:18;;;4302:62;-1:-1:-1;;;4380:18:1;;;4373:40;4430:19;;20308:111:0;4049:406:1;9335:229:0;9472:12;9504:52;9526:6;9534:4;9540:1;9543:12;9504:21;:52::i;:::-;9497:59;9335:229;-1:-1:-1;;;;9335:229:0:o;10421:455::-;10591:12;10649:5;10624:21;:30;;10616:81;;;;-1:-1:-1;;;10616:81:0;;4662:2:1;10616:81:0;;;4644:21:1;4701:2;4681:18;;;4674:30;4740:34;4720:18;;;4713:62;-1:-1:-1;;;4791:18:1;;;4784:36;4837:19;;10616:81:0;4460:402:1;10616:81:0;10709:12;10723:23;10750:6;-1:-1:-1;;;;;10750:11:0;10769:5;10776:4;10750:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10708:73;;;;10799:69;10826:6;10834:7;10843:10;10855:12;10799:26;:69::i;:::-;10792:76;10421:455;-1:-1:-1;;;;;;;10421:455:0:o;12994:644::-;13179:12;13208:7;13204:427;;;13236:10;:17;13257:1;13236:22;13232:290;;-1:-1:-1;;;;;6875:19:0;;;13446:60;;;;-1:-1:-1;;;13446:60:0;;5611:2:1;13446:60:0;;;5593:21:1;5650:2;5630:18;;;5623:30;5689:31;5669:18;;;5662:59;5738:18;;13446:60:0;5409:353:1;13446:60:0;-1:-1:-1;13543:10:0;13536:17;;13204:427;13586:33;13594:10;13606:12;14341:17;;:21;14337:388;;14573:10;14567:17;14630:15;14617:10;14613:2;14609:19;14602:44;14337:388;14700:12;14693:20;;-1:-1:-1;;;14693:20:0;;;;;;;;:::i;222:173:1:-;290:20;;-1:-1:-1;;;;;339:31:1;;329:42;;319:70;;385:1;382;375:12;319:70;222:173;;;:::o;400:322::-;477:6;485;493;546:2;534:9;525:7;521:23;517:32;514:52;;;562:1;559;552:12;514:52;598:9;585:23;575:33;;655:2;644:9;640:18;627:32;617:42;;678:38;712:2;701:9;697:18;678:38;:::i;:::-;668:48;;400:322;;;;;:::o;909:186::-;968:6;1021:2;1009:9;1000:7;996:23;992:32;989:52;;;1037:1;1034;1027:12;989:52;1060:29;1079:9;1060:29;:::i;:::-;1050:39;909:186;-1:-1:-1;;;909:186:1:o;1100:328::-;1177:6;1185;1193;1246:2;1234:9;1225:7;1221:23;1217:32;1214:52;;;1262:1;1259;1252:12;1214:52;1285:29;1304:9;1285:29;:::i;:::-;1275:39;;1333:38;1367:2;1356:9;1352:18;1333:38;:::i;:::-;1323:48;;1418:2;1407:9;1403:18;1390:32;1380:42;;1100:328;;;;;:::o;2058:277::-;2125:6;2178:2;2166:9;2157:7;2153:23;2149:32;2146:52;;;2194:1;2191;2184:12;2146:52;2226:9;2220:16;2279:5;2272:13;2265:21;2258:5;2255:32;2245:60;;2301:1;2298;2291:12;2690:184;2760:6;2813:2;2801:9;2792:7;2788:23;2784:32;2781:52;;;2829:1;2826;2819:12;2781:52;-1:-1:-1;2852:16:1;;2690:184;-1:-1:-1;2690:184:1:o;4867:258::-;4939:1;4949:113;4963:6;4960:1;4957:13;4949:113;;;5039:11;;;5033:18;5020:11;;;5013:39;4985:2;4978:10;4949:113;;;5080:6;5077:1;5074:13;5071:48;;;-1:-1:-1;;5115:1:1;5097:16;;5090:27;4867:258::o;5130:274::-;5259:3;5297:6;5291:13;5313:53;5359:6;5354:3;5347:4;5339:6;5335:17;5313:53;:::i;:::-;5382:16;;;;;5130:274;-1:-1:-1;;5130:274:1:o;5767:383::-;5916:2;5905:9;5898:21;5879:4;5948:6;5942:13;5991:6;5986:2;5975:9;5971:18;5964:34;6007:66;6066:6;6061:2;6050:9;6046:18;6041:2;6033:6;6029:15;6007:66;:::i;:::-;6134:2;6113:15;-1:-1:-1;;6109:29:1;6094:45;;;;6141:2;6090:54;;5767:383;-1:-1:-1;;5767:383:1:o

Swarm Source

ipfs://97ae739e56f182aebafc64d6bb1328bb55c22ca59bf9aef89fadeea89bba8eb6
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.