Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { BlastGasRefunder } from "../../../Blast/BlastGasRefunder.sol";
import { BasicTokenConfig } from "../Helpers/Token00Entities.sol";
import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import { Context } from "@openzeppelin/contracts/utils/Context.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title HyperBlast Basic Token 00 
 * @author HyperBlastTeam
 * @notice Customizable basic token contract
 * 1. No owner functions
 * 2. No tax
 * 3. No limits
 */
contract HyperBlastStandardToken00 is Context, ERC20, Ownable, BlastGasRefunder {

    uint8 internal immutable _decimals;

    constructor(
        BasicTokenConfig memory tokenConfig,
        address gasGov
    ) ERC20(
        tokenConfig.name, 
        tokenConfig.symbol
    ) {
        _mint(tokenConfig.supplyReceiver, tokenConfig.initialSupply * (10 ** tokenConfig.tokenDecimals));        
        _decimals = tokenConfig.tokenDecimals;        
        setBlastOwnerInt(gasGov);
        _transferOwnership(gasGov);
    }

    function decimals() public view override returns(uint8) {
        return _decimals;
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.0;

import "./Ownable.sol";

/**
 * @dev Contract module which provides 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} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view virtual returns (address) {
        return _pendingOwner;
    }

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)

pragma solidity ^0.8.0;

import "../token/ERC20/IERC20.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

/**
 * @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.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * 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}.
     *
     * 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 default value returned by this function, unless
     * it's 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;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _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;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _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;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _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 {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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
     *
     * 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);
        }
    }
}

// SPDX-License-Identifier: MIT
// 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;
    }
}

//import { console } from "hardhat/console.sol";

interface IBlast {
    function configureClaimableGas() external;
    function configureGovernor(address _governor) external;
    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256);
}

/**
 * @title BlastGasRefunder
 * @author HyperBlast team
 * @notice Contract to refund gas to users automatically
 * @dev CAREFUL, if you copy and use this contract you are doing that under you own responsability, 
 * we are not responsible of any losses you could suffer from bad implementations or bugs
 */
contract BlastGasRefunder {
    
    IBlast private iBlast = IBlast(0x4300000000000000000000000000000000000002);
    bytes4 private constant FSIGN_CLAIM_MAX_GAS = bytes4(keccak256("claimMaxGas(address,address)"));
    bytes4 private constant FSIGN_CLAIM_ALL_GAS = bytes4(keccak256("claimAllGas(address,address)"));
    
    /**
     * @notice refundmentPercentage has to be bigger or equal to this
     */
    uint8 public minRefundmentPercentage = 0;
    /**
     * @notice Percentage of claimed gas for refundments
     */
    uint8 public refundmentPercentage = 0;
    /**
     * @notice We claim the gas 1 time per day
     */
    uint24 public dayCounter = 0;
    /**
     * @notice Claim max / claim all gas available
     */
    bool public claimMax = true;
    /**
     * @notice The address that can trigger the custom gas functions from this contract
     */
    address public blastOwner;
    /**
     * @notice refundmentPercentage gets locked and can not be changed
     */
    bool public renounceUpdateRefundment = false;
    /**
     * @notice Max gas for calling gas refund functions
     */
    uint256 public maxGasForCall = 300000;
    /**
     * @notice Max amount that router can refund automatically
     */
    uint256 public maxRefund = 0.01 ether;

    modifier onlyBlastOwner() {
        require(msg.sender == blastOwner, "Only blast contract owner can manage blast features");
        _;
    }

    modifier gasRefunder() {
        uint256 gasStart = gasleft();
        _;
        //1 execution per day
        uint24 currentDayCounter = uint24(block.timestamp / 1 days);
        if(currentDayCounter != dayCounter) {
            claimGas(true);
            dayCounter = currentDayCounter;
        }
        //Refund if possible
        uint256 gasLeft = gasleft();
        uint256 gasToRefund = (gasLeft < gasStart ? gasStart - gasLeft : 0) * tx.gasprice;
        uint256 gasToRefundCap = gasToRefund <= maxRefund ? gasToRefund : maxRefund;
        uint256 refunmentsBal = address(this).balance;
        if(refundmentPercentage > 0 && refunmentsBal >= gasToRefundCap && gasToRefundCap > 0) {
            payable(tx.origin).send(gasToRefundCap);
        }
    }

    constructor() public {
        blastOwner = address(this);
        iBlast.configureGovernor(address(this)); //default governor        
        iBlast.configureClaimableGas();
    }

    /**
     * This function is used to claim pending gas, will run on 'safe mode' for automatic gas refunding call
     * @param lowLevel If we need a low level call (to prevent crashes on any case)
     */
    function claimGas(bool lowLevel) internal returns(uint256) {
        uint256 prevBal = address(this).balance;
        if(lowLevel) {
            bytes memory encodedCall = abi.encodeWithSelector(claimMax ? FSIGN_CLAIM_MAX_GAS : FSIGN_CLAIM_ALL_GAS, address(this), address(this));
            address(iBlast).call{ gas: maxGasForCall }(encodedCall);
        } else {
            if(claimMax) {
                iBlast.claimMaxGas(address(this), address(this));
            } else {
                iBlast.claimAllGas(address(this), address(this));
            }
        }
        uint256 afterBal = address(this).balance;
        if(refundmentPercentage < 100 && afterBal > prevBal) {
            uint256 refundAmount = (afterBal - prevBal) * (100 - refundmentPercentage) / 100;
            payable(blastOwner).send(refundAmount);
            return refundAmount;
        }
        return 0;
    }

    //#region Ownership

    function setBlastOwnerInt(address _blastOwner) internal {
        blastOwner = _blastOwner;
    }

    function setBlastOwner(address _blastOwner) public onlyBlastOwner {
        blastOwner = _blastOwner;
    }

    function unstuckETH() external onlyBlastOwner {
        payable(blastOwner).transfer(address(this).balance);
    }

    function setMaxGasForCall(uint256 _maxGas) external onlyBlastOwner {
        maxGasForCall = _maxGas;
    }

    function setMaxRefund(uint256 _maxRefund) external onlyBlastOwner {
        require(_maxRefund <= 0.5 ether, "Invalid max refund");
        maxRefund = _maxRefund;
    }

    function claimMode(bool _claimMax) external onlyBlastOwner {
        claimMax = _claimMax;
    }

    function updateRefundmentPercentage(uint8 newRFPC) external onlyBlastOwner {
        require(!renounceUpdateRefundment, "UPDATES NOT ALLOWED");
        require(newRFPC >= minRefundmentPercentage, "Min. gas for refundment has to be bigger tan minimal");
        require(newRFPC <= 100, "Max. gas for refundment is 100%");
        refundmentPercentage = newRFPC;
    }

    function renounceOwnerUpdateRefundment() external onlyBlastOwner {
        require(!renounceUpdateRefundment, "Already renounced");
        renounceUpdateRefundment = true;
    }    

    /**
     * @notice Can be used to claim the pending gas and to check the gas pending to claim by simulation
     */
    function claim() external onlyBlastOwner returns(uint256) {
        return claimGas(false);
    }

    //#endregion    
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { 
    BasicTokenConfig, 
    TransactionsLimitsConfig, 
    DisableLimitOption, 
    DisableLimitsConfig, 
    DEXConfig,
    TaxesConfigBase10000, 
    TaxesConfigReceivers    
} from "../Helpers/TokenAdvanced00Entities.sol";
import { HyperBlastStandardToken01 } from "../Standard/HyperBlastStandardToken01.sol";
import { IHyperBlastV2Router02 } from "../../../UniV2Fork/Interfaces/IHyperBlastV2Router02.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
//import { console } from "hardhat/console.sol";

/* solhint-disable no-empty-blocks */

/**
 * @title HyperBlast Advanced Token 00
 * @author HyperBlastTeam
 * @notice Customizable advanced token contract
 * 1. Owner can add more liquidity pairs to apply taxes
 * 2. Configurable taxes -> dev, marketing, liq, charity (optional: increased during limits)
 * 3. Max wallet and max tx, (optional: for some amount of swaps, certain timestamp or blocks)
 */
contract HyperBlastAdvancedToken00 is HyperBlastStandardToken01 {

    TaxesConfigBase10000 public _taxesConfigBase10000;
    TaxesConfigReceivers public _taxesConfigReceivers;    

    IHyperBlastV2Router02 private _router;

    address public _weth;
    address public _liqPairSwapback;
    bool internal _inSwap = false;
    uint256 public TAX_SWAP_THRESHOLD;
    uint256 public MAX_TAX_SWAP;

    modifier lockTheSwap() {
        _inSwap = true;
        _;
        _inSwap = false;
    }

    constructor(
        BasicTokenConfig memory basicTokenConfig,
        TransactionsLimitsConfig memory transactionsLimitsConfig,
        DisableLimitsConfig memory disableLimitsConfig,      
        DEXConfig memory dexConfig,
        address gasGov,
        TaxesConfigBase10000 memory taxesConfigBase10000,
        TaxesConfigReceivers memory taxesConfigReceivers
    ) HyperBlastStandardToken01(
        basicTokenConfig, 
        transactionsLimitsConfig, 
        disableLimitsConfig, 
        dexConfig,
        gasGov
    ) {
        TAX_SWAP_THRESHOLD = totalSupply() / 2000;
        MAX_TAX_SWAP = totalSupply() / 1000;
        require(
            (taxesConfigBase10000.charityTax + 
            taxesConfigBase10000.devTax + 
            taxesConfigBase10000.liquidityTax + 
            taxesConfigBase10000.marketingTax) == taxesConfigBase10000.totalTax, "Invalid tax config");   
        require(taxesConfigBase10000.totalTaxIfLimits < 10000, "Invalid tax in limits config");
        _liqPairSwapback = dexConfig.tokenLiq;
        _taxesConfigBase10000 = taxesConfigBase10000;
        _taxesConfigReceivers = taxesConfigReceivers;
        _router = IHyperBlastV2Router02(dexConfig.router);
        _weth = _router.WETH();
        _approve(address(this), address(_router), type(uint256).max);
        IERC20(_liqPairSwapback).approve(address(_router), type(uint256).max);
    }

    /**
     * @notice Returns the router address (uniswapv2 fork) used for swapbacks
     */
    function getRouterAddress() external returns(address) {
        return address(_router);
    }

    //#region Admin

    function configTaxReceivers(TaxesConfigReceivers memory taxesConfigReceivers) external onlyOwner {
        _taxesConfigReceivers.charityReceiver = taxesConfigReceivers.charityReceiver;
        _taxesConfigReceivers.devTaxReceiver = taxesConfigReceivers.devTaxReceiver;
        _taxesConfigReceivers.liquidityReceiver = taxesConfigReceivers.liquidityReceiver;
        _taxesConfigReceivers.marketingTaxReceiver = taxesConfigReceivers.marketingTaxReceiver;
    }

    //#endregion

    //#region Tax management

    event SendTaxPaymentError();
    /**
     * @dev Transfer could fail because of recipient address
     * @param _tokensSend tokens amount
     * @param _receiver wallet that receives the payment
     */
    function sendPaymentToWallet(uint256 _tokensSend, address _receiver) internal {
        bool success = payable(_receiver).send(_tokensSend);
        if(success) {
            //console.log('Eth payment ok %s', _tokensSend);
        } else {
            emit SendTaxPaymentError();
        }
    }

    event BuybackForLiqError();
    event AddLiqError();

    function sendTokensToLiquidity(uint256 _tokensSend, address _liqReceiver) internal lockTheSwap {
        address[] memory path = new address[](2);        
        path[0] = _weth;      
        path[1] = address(this);        

        uint256[] memory amounts = _router.getAmountsOut(_tokensSend, path);

        try _router.addLiquidityETH{ value: _tokensSend }(
            address(this), 
            amounts[1], 
            0,
            0, 
            _liqReceiver,
            block.timestamp
        ) {
            //console.log('add liq ok');    
        } catch Error(string memory _error)  {
            //console.log(_error);
            emit AddLiqError();
        } catch  {
            //console.log('add liq assert error?');
            emit AddLiqError();
        }
    }

    /**
     * @param _tokensSend tokens to split between the tax receivers
     */
    function sendETHToFee(uint256 _tokensSend) internal {
        TaxesConfigReceivers memory __taxesConfigReceivers = _taxesConfigReceivers;
        TaxesConfigBase10000 memory __taxesConfigBase10000 = _taxesConfigBase10000;
        if(__taxesConfigBase10000.devTax > 0) {
            sendPaymentToWallet(_tokensSend * __taxesConfigBase10000.devTax / __taxesConfigBase10000.totalTax, __taxesConfigReceivers.devTaxReceiver);
        }
        if(__taxesConfigBase10000.marketingTax > 0) {
            sendPaymentToWallet(_tokensSend * __taxesConfigBase10000.marketingTax / __taxesConfigBase10000.totalTax, __taxesConfigReceivers.marketingTaxReceiver);
        }
        if(__taxesConfigBase10000.charityTax > 0) {
            sendPaymentToWallet(_tokensSend * __taxesConfigBase10000.charityTax / __taxesConfigBase10000.totalTax, __taxesConfigReceivers.charityReceiver);
        }
        if(__taxesConfigBase10000.liquidityTax > 0) {
            sendTokensToLiquidity(_tokensSend * __taxesConfigBase10000.liquidityTax / __taxesConfigBase10000.totalTax, __taxesConfigReceivers.liquidityReceiver);
        }
    }

    /**
     * @notice Payments can be processed manually you can indicate an amount and will be distributed between the tax receivers
     * @param _tokensSend tokens to split between the tax receivers
     * @param _safe if true ensures all eth indicated has been transferred
     */
    function sendETHToFeeManual(uint256 _tokensSend, bool _safe) external onlyOwner {
        uint256 prevBal = address(this).balance;
        sendETHToFee(_tokensSend);
        uint256 afterBal = address(this).balance;
        require(!_safe || (prevBal - afterBal >= _tokensSend), "Error sending tokens");
    }

    event SwapbackError();
    function swapTokensForETH(uint256 _tokensAmount) internal lockTheSwap {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _liqPairSwapback;     
        if(_liqPairSwapback != _weth) {
            path[2] = _weth;     
        }
        try _router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            _tokensAmount,
            0,
            path,
            address(this),
            block.timestamp
        ) {
            //console.log('Swapback ok');    
        } catch Error(string memory _error)  {
            //console.log(_error);
            emit SwapbackError();
        } catch  {
            //console.log('assert error?');
            emit SwapbackError();
        }
    }

    function min(uint256 a, uint256 b) private pure returns (uint256) {
        return (a > b) ? b : a;
    }

    /**
     * @dev Manage tax payments
     * @param to Who receives the tokens?
     * @param amount How much tokens?
     */
    function feesManager(address to, uint256 amount) internal {
        uint256 taxedAmount = amount * _taxesConfigBase10000.totalTax / 10000;
        if(limitsEnabled()) {
            taxedAmount = amount * _taxesConfigBase10000.totalTaxIfLimits / 10000;
        }
        
        if(taxedAmount > 0) {
            _transfer(to, address(this), taxedAmount);        
        }  

        //console.log('Amount taxed %s', taxedAmount);
    }

    /**
     * @dev Manage swapbacks
     * @param to Who receives the tokens?
     * @param amount How much tokens?
     */
    function swapbackManager(address to, uint256 amount) internal {
        uint256 contractTokenBalance = balanceOf(address(this));
        //console.log('Amount bought %s', amount);
        //console.log('Contract balance %s', contractTokenBalance);
        //console.log('Tax swap threshold %s', TAX_SWAP_THRESHOLD);
        if (!_inSwap && _liqPairs[to] && contractTokenBalance > TAX_SWAP_THRESHOLD && amount > 0) {
            uint256 amountSwap = min(amount, min(contractTokenBalance, MAX_TAX_SWAP));
            TaxesConfigBase10000 memory __taxesConfigBase10000 = _taxesConfigBase10000;
            uint256 amountSwapSubstractLiq =  amountSwap * __taxesConfigBase10000.liquidityTax / __taxesConfigBase10000.totalTax;           

            //console.log('Swapping %s', amountSwap - amountSwapSubstractLiq);
            swapTokensForETH(amountSwap - amountSwapSubstractLiq);
            uint256 contractETHBalance = address(this).balance;
            if (contractETHBalance > 0) {
                sendETHToFee(contractETHBalance);
            }
        }  
    }

    //#endregion

    //#region Tax checks and limits

    /**
     * @dev Tax only on swap, we check if it is a buy or a sell
     * @param from sender
     * @param to receiver
     */
    function ignoreTaxChecks(address from, address to) internal view returns (bool) {
        return (!_liqPairs[to] && !_liqPairs[from]) || _inSwap || from == address(this) || to == address(this);
    }

    function _beforeTokenTransfer2(address from, address to, uint256 amount) internal override {
        swapbackManager(to, amount);

        //To extend
        _beforeTokenTransfer3(from, to, amount);
    }

    function _afterTokenTransfer2(address from, address to, uint256 amount) internal override {        
        if(ignoreTaxChecks(from, to)) return;

        feesManager(to, amount);

        //To extend
        _afterTokenTransfer3(from, to, amount);
    }

    //#endregion

    /*solhint-disable no-empty-blocks*/

    function _beforeTokenTransfer3(address from, address to, uint256 amount) internal virtual { }

    function _afterTokenTransfer3(address from, address to, uint256 amount) internal virtual { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { 
    BasicTokenConfig, 
    TransactionsLimitsConfig, 
    DisableLimitOption, 
    DisableLimitsConfig, 
    DEXConfig,
    TaxesConfigBase10000, 
    TaxesConfigReceivers,
    AntibotConfig
} from "../Helpers/TokenAdvanced01Entities.sol";
import { HyperBlastAdvancedToken00 } from "./HyperBlastAdvancedToken00.sol";

/**
 * @title HyperBlast Advanced Token 00
 * @author HyperBlastTeam
 * @notice Customizable advanced token contract
 * 1. Owner can add more liquidity pairs to apply taxes
 * 2. Configurable taxes -> dev, marketing, liq, charity
 * 3. Max wallet and max tx, (optional: for some amount of swaps, certain timestamp or blocks)
 * 4. Customizable auto and/or manual blacklist
 */
contract HyperBlastAdvancedToken01 is HyperBlastAdvancedToken00 {

    AntibotConfig private _antibotConfig;
    uint256 internal _launchBlock;
    mapping(address => bool) internal _blacklist;

    constructor(
        BasicTokenConfig memory basicTokenConfig,
        TransactionsLimitsConfig memory transactionsLimitsConfig,
        DisableLimitsConfig memory disableLimitsConfig,      
        DEXConfig memory dexConfig,
        address gasGov,
        TaxesConfigBase10000 memory taxesConfigBase10000,
        TaxesConfigReceivers memory taxesConfigReceivers,
        AntibotConfig memory antibotConfig
    ) HyperBlastAdvancedToken00(
        basicTokenConfig, 
        transactionsLimitsConfig, 
        disableLimitsConfig, 
        dexConfig,
        gasGov,
        taxesConfigBase10000,
        taxesConfigReceivers
    ) {
        _antibotConfig = antibotConfig;
        _launchBlock = block.timestamp;
    }

    function manageBlacklist(address adr, bool blacklist) external onlyOwner {
        require(_antibotConfig.manualManagement, "Your antibot config does not admit manual management");
        require(!_antibotConfig.manualOnlyUnBlacklist || !blacklist, "Your antibot config only admits manual unblacklist");
        _blacklist[adr] = blacklist;
    }

    /*solhint-disable no-empty-blocks*/

    function autoBlacklistSnipers(address from, address to) internal {
        if(block.number < (_launchBlock + _antibotConfig.nBlocks) && _liqPairs[from]) {
            _blacklist[to] = true;
        }
    }

    function _beforeTokenTransfer3(address from, address to, uint256 amount) internal override {
        if(_antibotConfig.revertOnBuy) {
            autoBlacklistSnipers(from, to);
        }

        require(!_blacklist[to], "Receiver blacklisted...");
        require(!_blacklist[from], "Sender blacklisted...");

        autoBlacklistSnipers(from, to);

        _beforeTokenTransfer4(from, to, amount);
    }

    function _afterTokenTransfer3(address from, address to, uint256 amount) internal override { 
        _afterTokenTransfer4(from, to, amount);
    }

    function _beforeTokenTransfer4(address from, address to, uint256 amount) internal virtual { }

    function _afterTokenTransfer4(address from, address to, uint256 amount) internal virtual { }
}

//TODO add rewards

//TODO add reflections

struct BasicTokenConfig {
    string name;
    string symbol;
    uint8 tokenDecimals;
    uint256 initialSupply;
    address supplyReceiver;
}

import { BasicTokenConfig } from "../Helpers/Token00Entities.sol";

struct TransactionsLimitsConfig {
    uint8 maxTxPc;
    uint8 maxWalletPc;
}

enum DisableLimitOption {
    none,
    nSwaps,
    untilTimestap,
    nBlocks
}

/**
 * @dev 
 * if option nSwaps -> Number swaps required to disable limits
 * if option nBlocks -> Blocks since launch to disable limits
 * if option untilTimestap -> Timestamp to disable limits
 */
struct DisableLimitsConfig {        
    DisableLimitOption disableLimitOption;
    uint256 disableLimitBound;
}

/**
 * @dev
 * We need this to predict liquidity pair, has to be exempted from taxes
 */
struct DEXConfig {
    address router;
    address tokenLiq;
}

import { BasicTokenConfig, TransactionsLimitsConfig, DisableLimitOption, DisableLimitsConfig, DEXConfig } from "../Helpers/Token01Entities.sol";

struct TaxesConfigBase10000 {
    uint256 devTax;
    uint256 marketingTax;
    uint256 liquidityTax;
    uint256 charityTax;
    uint256 totalTax;
    uint256 totalTaxIfLimits;
}

struct TaxesConfigReceivers {
    address devTaxReceiver;
    address marketingTaxReceiver;
    address liquidityReceiver;
    address charityReceiver;
}

import { 
    BasicTokenConfig, 
    TransactionsLimitsConfig, 
    DisableLimitOption, 
    DisableLimitsConfig, 
    DEXConfig, 
    TaxesConfigBase10000, 
    TaxesConfigReceivers 
} from "./TokenAdvanced00Entities.sol";

/**
 * @dev Users gets autoblacklisted if he buys before nBlocks pass since launch
 */
struct AntibotConfig {
    uint8 nBlocks;
    bool revertOnBuy;
    bool manualManagement;
    bool manualOnlyUnBlacklist;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { BlastGasRefunder } from "../../Blast/BlastGasRefunder.sol";
import { Context } from "@openzeppelin/contracts/utils/Context.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import { Ownable2Step } from "@openzeppelin/contracts/access/Ownable2Step.sol";
import { IHyperBlastV2Router02 } from "../../UniV2Fork/Interfaces/IHyperBlastV2Router02.sol";
import { HyperBlastTokenFactoryV1Iface } from "./HyperBlastTokenFactoryV1Iface.sol";

/* solhint-disable no-empty-blocks */

interface HyperBlastTokenFactoriesManagerIface {
    function processETHpayment() external payable;
    function processHYPEpayment(address _user) external;
    function registerContract(address _deployedToken) external;
}

/**
 * @title HyperBlast Token Factory/Generator 
 * @author HyperBlastTeam
 * @notice This contract has been created to deploy contracts from HyperBlast DAPP
 * Cost: minor or equals to 0.025 ETH or same value with discount in HYPE tokens
 * Benefits: 
 * 1. You can create a contract with a zero-code solution from HyperBlast DAPP
 * 2. Tokens deployed from HyperBlastTokenFactoryV1 contract, safe an audited code
 * 3. Automatic verification
 * 4. You can check and manage your deployed contracts from HyperBlast DAPP
 */
contract HyperBlastTokenFactoriesManager is HyperBlastTokenFactoriesManagerIface, Ownable2Step, BlastGasRefunder {

    IHyperBlastV2Router02 public immutable HYPE_ROUTER_IFACE;
    address public HYPE;
    address public immutable WETH;
    IERC20 private HYPE_IFACE;

    /**
     * @notice HyperBlast upgradeable token factory 
     */
    bytes private factoryV1bytecode;

    /**
     * @notice Cost per deployment
     */
    uint256 public deployCostEth = 0.025 ether;

    /**
     * @notice Receives ETH payments and HYPE payments
     */
    address public feeReceiver = address(0x0);
    /**
     * @notice If you pay using HYPE you will get a discount
     */
    uint8 public hypePercentageDiscount = 15; //15% off by default
    /**
     * @notice When you pay using HYPE some tokens are burned and the rest are sent to the team
     */
    uint8 public hypePercentageBurning = 50; //50% by default

    //
    uint256 public totalDeployedContracts;
    mapping(uint256 => address) public deployedContracts;
    mapping(address => bool) public isDeployedContract;

    /**
     * @notice Independent factory contract is deployed for each user
     */
    mapping(address => bool) public isFactory;
    mapping(address => address) public userFactory;
    mapping(uint256 => address) public deployedFactories;
    uint256 public totalFactories;

    event OnCreateFactory(address user, address factory, uint256 totalFactories);
    event OnRegisterContract(address factory, address newContract);

    constructor(bytes memory _factoryV1bytecode, address _hypeAddress, address _routerAddress, address _feeReceiver) {
        factoryV1bytecode = _factoryV1bytecode;
        HYPE_ROUTER_IFACE = IHyperBlastV2Router02(_routerAddress);
        HYPE = _hypeAddress;
        WETH = HYPE_ROUTER_IFACE.WETH();
        HYPE_IFACE = IERC20(HYPE);

        if(_feeReceiver != address(0x0)) {
            feeReceiver = _feeReceiver;
        }
        setBlastOwnerInt(owner());
    }
    
    //#region VIEWS

    /**
     * @notice This enables you to manage the contracts from our UI
     */
    function getDeployedContractsUser(address _user, uint256 _index, uint256 _nTake) public view returns(address[] memory) {
        address _userFactory = userFactory[_user];
        return HyperBlastTokenFactoryV1Iface(_userFactory).getUserContracts(_index, _nTake);
    }

    function getNumberDeployedContractsUser(address _user, uint256 _index, uint256 _nTake) public view returns(uint256) {
        address _userFactory = userFactory[_user];
        return HyperBlastTokenFactoryV1Iface(_userFactory).getUserContracts(_index, _nTake).length;
    }

    function getDeployedContracts(uint256 _index, uint256 _nTake) public view returns(address[] memory) {
        address[] memory addressReturn = new address[](_nTake);
        uint256 nTaken = 0;

        for (uint256 index = _index; index <= totalDeployedContracts; index++) {
            addressReturn[index] = deployedContracts[index];
            nTaken++;
            if(nTaken >= _nTake) break;
        }

        return addressReturn;
    }

    function getDeployedFactories(uint256 _index, uint256 _nTake) public view returns(address[] memory) {
        address[] memory addressReturn = new address[](_nTake);
        uint256 nTaken = 0;

        for (uint256 index = _index; index <= totalFactories; index++) {
            addressReturn[index] = deployedFactories[index];
            nTaken++;
            if(nTaken >= _nTake) break;
        }

        return addressReturn;
    }

    function getHypeDeployCost() public view returns(uint256) {
        address[] memory hype_buy_path = new address[](2);
        hype_buy_path[0] = WETH;
        hype_buy_path[1] = HYPE;
        uint256[] memory amounts = HYPE_ROUTER_IFACE.getAmountsOut(deployCostEth, hype_buy_path);
        require(amounts.length == 2, "HYPE payment unavailable");
        return amounts[1] * (100 - hypePercentageDiscount) / 100;
    }

    //#endregion

    /**
     * @notice Each user will have his own factory that only can be used by himself
     */
    function createFactory() external gasRefunder {
        require(userFactory[msg.sender] == address(0x0), "You already have a factory");
        address _userFactory; 
        bytes memory deploymentBytecode = abi.encodePacked(factoryV1bytecode, abi.encode(msg.sender));
        /*solhint-disable-next-line*/
        assembly {
            _userFactory := create(0, add(deploymentBytecode, 0x20), mload(deploymentBytecode))
        }
        require(_userFactory != address(0), "Error deploying factory, contact developers if persists");
        userFactory[msg.sender] = address(_userFactory);
        isFactory[address(_userFactory)] = true;
        totalFactories++;
        emit OnCreateFactory(msg.sender, address(_userFactory), totalFactories);
    }

    function claimFactoryGas(address adr, bool safe) public returns(uint256) {
        (, bytes memory data) = adr.call(abi.encodeWithSignature("claim()"));
        payable(owner()).send(address(this).balance);
        if(safe) {
            return abi.decode(data, (uint256));
        } else {
            return 0;
        }
    }

    function claimDeployedFactoriesGas(uint256 _index, uint256 _nTake, bool safe) public returns(uint256) {
        uint256 gasClaimed = 0;
        uint256 nTaken = 0;

        for (uint256 index = _index; index <= totalFactories; index++) {
            gasClaimed += claimFactoryGas(deployedFactories[index], safe);
            nTaken++;
            if(nTaken >= _nTake) break;
        }

        return gasClaimed;
    }

    //#region EXTERNALS    

    function processETHpayment() external payable {
        require(isFactory[msg.sender], "Only deployed factories can perform payments");
        require(msg.value == deployCostEth, "Error processing ETH payment, send exact amount or transaction will be reverted");
        /*solhint-disable-next-line*/
        bool result = payable(feeReceiver).send(msg.value);
        require(result, "Error sending payment to fee receiver, wait until developers solve the issue, sorry");                
    }

    function processHYPEpayment(address _user) external {
        require(isFactory[msg.sender], "Only deployed factories can perform payments");
        uint256 hypeDeployCost = getHypeDeployCost();

        try HYPE_IFACE.transferFrom(_user, address(this), hypeDeployCost) {
            //OK
        } catch {
            revert("Error processing HYPE payment, ensure your balance and allowance is enough");
        }        

        uint256 burningAmount = hypeDeployCost * hypePercentageBurning / 100;
        uint256 paymentAmount = hypeDeployCost * (100 - hypePercentageBurning) / 100;

        try HYPE_IFACE.transfer(address(0xdEad), burningAmount) {
            //OK
        } catch  {
            /*solhint-disable-next-line*/
            (bool success,) = address(HYPE_IFACE).call(abi.encodeWithSignature("burn(uint256)", abi.encode(burningAmount)));
            require(success, "Error burning tokens, wait until developers solve the issue, sorry");
        }

        try HYPE_IFACE.transfer(feeReceiver, paymentAmount) {
            //OK
        } catch {
            revert("Error processing HYPE payment (contract -> receiver), wait until developers solve the issue, sorry");
        } 
    }

    function registerContract(address _deployedToken) external {
        require(isFactory[msg.sender], "Only deployed factories can register contracts");       
        deployedContracts[totalDeployedContracts] = _deployedToken;
        totalDeployedContracts++;
        isDeployedContract[_deployedToken] = true;
        claimFactoryGas(msg.sender, false);
        emit OnRegisterContract(msg.sender, _deployedToken);
    }

    //#endregion

    //#region OWNER

    function setFactoryV1bytecode(bytes memory _factoryV1bytecode) public onlyOwner {
        factoryV1bytecode = _factoryV1bytecode;
    }

    function setFeesReceiver(address _feeReceiver) public onlyOwner {
        require(_feeReceiver != address(0x0) && _feeReceiver != address(0xdEaD), "Invalid address");
        feeReceiver = _feeReceiver;
    }

    function setETHprice(uint256 _deployCostEth) public onlyOwner {
        require(_deployCostEth <= 0.2 ether, "Deployment cost can not be bigger than 0.2 eth");
        deployCostEth = _deployCostEth;
    }

    function setNewHype(address _newHype) public onlyOwner {
        HYPE = _newHype;
        HYPE_IFACE = IERC20(_newHype);
    }

    function setHypeDiscountPercentage(uint8 _hypePercentageDiscount) public onlyOwner {
        require(_hypePercentageDiscount >= 10, "HYPE discount has to be 10% or bigger");
        hypePercentageDiscount = _hypePercentageDiscount;
    }

    function setHypeBurningPercentage(uint8 _hypePercentageBurning) public onlyOwner {
        require(_hypePercentageBurning >= 50, "HYPE burning percentage has to be 50% or bigger");
        hypePercentageBurning = _hypePercentageBurning;
    }

    function extractStuckETH() public onlyOwner {
        payable(address(msg.sender)).transfer(address(this).balance);
    }

    function extractStuckHYPE() public onlyOwner {
        HYPE_IFACE.transfer(msg.sender, HYPE_IFACE.balanceOf(address(this)));
    }

    function extractStuckToken(address _adr) public onlyOwner {
        IERC20(_adr).transfer(msg.sender, IERC20(_adr).balanceOf(address(this)));
    }

    //#endregion

    receive() external payable {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { BlastGasRefunder } from "../../Blast/BlastGasRefunder.sol";
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import { HyperBlastTokenFactoryV1Iface } from "./HyperBlastTokenFactoryV1Iface.sol";

/* solhint-disable no-console */
/* solhint-disable no-empty-blocks */

interface HyperBlastTokenFactoriesManagerIface {
    function deployCostEth() external returns(uint256);
    function processETHpayment() external payable;
    function processHYPEpayment(address _user) external;
    function registerContract(address _deployedToken) external;
}

contract HyperBlastTokenFactoryV1 is HyperBlastTokenFactoryV1Iface, BlastGasRefunder {
    HyperBlastTokenFactoriesManagerIface private factoriesManager;

    mapping(uint256 => address) public deployedContracts;
    uint256 public totalDeployedContracts;

    address public immutable owner;

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can use this contract");
        _;
    }

    constructor(address _owner) {
        owner = _owner;    
        factoriesManager = HyperBlastTokenFactoriesManagerIface(msg.sender);
        setBlastOwnerInt(msg.sender); //to factories manager
    }

    //#region VIEWS

    function getUserContracts(uint256 _index, uint256 _nTake) public view returns(address[] memory) {
        address[] memory addressReturn = new address[](_nTake);
        uint256 nTaken = 0;

        for (uint256 index = _index; index <= totalDeployedContracts; index++) {
            addressReturn[index] = deployedContracts[index];
            nTaken++;
            if(nTaken >= _nTake) break;
        }

        return addressReturn;
    }

    //#endregion

    /**
     * @dev HyperBlast is NOT responsible for consecuences derived from using this contract directly
     * only use this through the HyperBlast DAPP
     * @param bytecodeToDeploy contract bytecode + parameters
     * @param ethPaymentSelected are you gonna paid using HYPE or ETH?
     */
    function deployToken(bytes memory bytecodeToDeploy, bool ethPaymentSelected) external payable onlyOwner gasRefunder returns(address) {        

        uint256 payableAmount = msg.value;

        //Process payments
        if(ethPaymentSelected) {       
            //Deployment cost
            uint256 deployCostEth = factoriesManager.deployCostEth();
            require(payableAmount >= deployCostEth, "ETH sent is not enough to pay deployment");     

            try factoriesManager.processETHpayment{ value: deployCostEth }() {
                //OK
            } catch Error(string memory reason) {
                revert(reason);
            }

            payableAmount -= deployCostEth;
        } else {
            try factoriesManager.processHYPEpayment(msg.sender) {
                //OK
            } catch Error(string memory reason) {
                revert(reason);
            }
        }

        //Deploy new contract
        address deployedToken;        
        /*solhint-disable-next-line*/
        assembly {
            deployedToken := create(payableAmount, add(bytecodeToDeploy, 0x20), mload(bytecodeToDeploy))
        }
        require(deployedToken != address(0), "Error deploying contract, contact developers if persists");

        //Son?
        (bool success, bytes memory data) = deployedToken.call(abi.encodeWithSignature("sonContract()"));
        if(success) {
            deployedToken = abi.decode(data, (address));
        }

        //Register contract for user
        try factoriesManager.registerContract(deployedToken) {
            //OK
        } catch Error(string memory reason) {
            revert(reason);
        }

        //Local register
        deployedContracts[totalDeployedContracts] = deployedToken;
        totalDeployedContracts++;

        return  deployedToken;
    }    

    //#region OWNER

    function extractStuckETH() public onlyOwner {
        payable(address(msg.sender)).transfer(address(this).balance);
    }

    function extractStuckToken(address _adr) public onlyOwner {
        IERC20(_adr).transfer(msg.sender, IERC20(_adr).balanceOf(address(this)));
    }

    //#endregion

    receive() external payable {}
}

interface HyperBlastTokenFactoryV1Iface {
    function getUserContracts(uint256 _index, uint256 _nTake) external view returns(address[] memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { 
    BasicTokenConfig, 
    TransactionsLimitsConfig, 
    DisableLimitOption, 
    DisableLimitsConfig, 
    DEXConfig,
    TaxesConfigBase10000, 
    TaxesConfigReceivers    
} from "../Helpers/TokenAdvanced00Entities.sol";
import { HyperBlastAdvancedToken00 } from "../Advanced/HyperBlastAdvancedToken00.sol";
//import { console } from "hardhat/console.sol";

/**
 * @title HyperBlast Advanced Token 00 real fair launch
 * @author HyperBlastTeam
 * @notice Customizable advanced token contract
 * 1. Owner can add more liquidity pairs to apply taxes
 * 2. Configurable taxes -> dev, marketing, liq, charity
 * 3. Max wallet and max tx, (optional: for some amount of swaps, certain timestamp or blocks)
 * 4. Liquidity on deployment
 * @dev We call this 'real fair launch' because an unknown contract is so hard to snipe
 */
contract HyperBlastAdvancedToken00RFLDeployer {
    address public immutable sonContract;

    constructor(
        BasicTokenConfig memory basicTokenConfig,
        TransactionsLimitsConfig memory transactionsLimitsConfig,
        DisableLimitsConfig memory disableLimitsConfig,      
        DEXConfig memory dexConfig,
        address gasGov,
        TaxesConfigBase10000 memory taxesConfigBase10000,
        TaxesConfigReceivers memory taxesConfigReceivers,
        uint8 pcTokensLiq
    ) payable {
        require(msg.value >= 1000, "minimum is 1000 wei");
        require(pcTokensLiq <= 100, "pcTokensLiq can not be bigger than 100");

        address realSupplyReceiver = basicTokenConfig.supplyReceiver;

        //We override supply receiver because this contract has to add the liquidity
        basicTokenConfig.supplyReceiver = address(this);
        HyperBlastAdvancedToken00 _contract = new HyperBlastAdvancedToken00(
            basicTokenConfig,
            transactionsLimitsConfig,
            disableLimitsConfig,
            dexConfig,
            gasGov,
            taxesConfigBase10000,
            taxesConfigReceivers
        );
        sonContract = address(_contract);

        uint256 adrBalance = _contract.balanceOf(address(this));
        uint256 liquidityAmount = adrBalance * pcTokensLiq / 100;

        if(pcTokensLiq < 100) {
            //We send to deployer the rest of tokens
            _contract.transfer(realSupplyReceiver, adrBalance - liquidityAmount);
        }   

        _contract.approve(dexConfig.router, type(uint256).max);
        (bool success,) = dexConfig.router.call{gas : gasleft(), value: msg.value}(
            // addLiquidityETH(address,uint256,uint256,uint256,address,uint256)
            abi.encodeWithSelector(
                0xf305d719,
                address(_contract),
                liquidityAmount,
                0,
                0,
                realSupplyReceiver,
                block.timestamp
            )
        );   

        //We send the ownership
        //_contract.transferOwnership(realSupplyReceiver);

        require(success, "ADD_LIQUIDITY_ETH_FAILED");
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { BasicTokenConfig, TransactionsLimitsConfig, DisableLimitOption, DisableLimitsConfig, DEXConfig } from "../Helpers/Token01Entities.sol";
import { HyperBlastStandardToken01 } from "../Standard/HyperBlastStandardToken01.sol";

/**
 * @title HyperBlast Basic Token 01 real fair launch 
 * @author HyperBlastTeam
 * @notice Customizable basic token contract
 * 1. No owner
 * 2. No tax
 * 3. Max wallet and max tx, (optional: for some amount of swaps, certain timestamp or blocks)
 * 4. Liquidity on deployment
 * @dev We call this 'real fair launch' because an unknown contract is so hard to snipe
 */
contract HyperBlastStandardToken01RFLDeployer {
    address public immutable sonContract;

    constructor(
        BasicTokenConfig memory tokenConfig,
        TransactionsLimitsConfig memory transactionsLimitsConfig,
        DisableLimitsConfig memory disableLimitsConfig,     
        DEXConfig memory dexConfig,   
        address gasGov,
        uint8 pcTokensLiq
    ) payable {
        require(msg.value >= 1000, "minimum is 1000 wei");
        require(pcTokensLiq <= 100, "pcTokensLiq can not be bigger than 100");

        address realSupplyReceiver = tokenConfig.supplyReceiver;

        //We override supply receiver because this contract has to add the liquidity
        tokenConfig.supplyReceiver = address(this);
        HyperBlastStandardToken01 _contract = new HyperBlastStandardToken01(
            tokenConfig,
            transactionsLimitsConfig,
            disableLimitsConfig,
            dexConfig,
            gasGov
        );
        sonContract = address(_contract);

        uint256 adrBalance = _contract.balanceOf(address(this));
        uint256 liquidityAmount = adrBalance * pcTokensLiq / 100;

        if(pcTokensLiq < 100) {
            //We send to deployer the rest of tokens
            _contract.transfer(realSupplyReceiver, adrBalance - liquidityAmount);
        }

        _contract.approve(dexConfig.router, type(uint256).max);
        (bool success,) = dexConfig.router.call{gas : gasleft(), value: msg.value}(
            // addLiquidityETH(address,uint256,uint256,uint256,address,uint256)
            abi.encodeWithSelector(
                0xf305d719,
                address(_contract),
                liquidityAmount,
                0,
                0,
                realSupplyReceiver,
                block.timestamp
            )
        );

        //We send the ownership
        //_contract.transferOwnership(realSupplyReceiver);

        require(success, "ADD_LIQUIDITY_ETH_FAILED");
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { BasicTokenConfig, TransactionsLimitsConfig, DisableLimitOption, DisableLimitsConfig, DEXConfig } from "../Helpers/Token01Entities.sol";
import { HyperBlastStandardToken00 } from "./HyperBlastStandardToken00.sol";
import { IHyperBlastV2Router02 } from "../../../UniV2Fork/Interfaces/IHyperBlastV2Router02.sol";
import { IHyperBlastV2Factory } from "../../../UniV2Fork/Interfaces/IHyperBlastV2Factory.sol";
import { Address } from "@openzeppelin/contracts/utils/Address.sol";

/**
 * @title HyperBlast Basic Token 01
 * @author HyperBlastTeam
 * @notice Customizable basic token contract
 * 1. No owner functions
 * 2. No tax
 * 3. Max wallet and max tx, (optional: for some amount of swaps, certain timestamp or blocks)
 */
contract HyperBlastStandardToken01 is HyperBlastStandardToken00 {
    
    //#region Vars
 
    /**
     * @dev Limits does not apply until the contract finish initialization
     */
    bool internal _initialized;    

    /**
     * @dev Limits are not applied to supply received because he has to add liquidity
     */
    address public _supplyReceiver;

    /**
     * @dev Liquidity pairs are exempted from wallet limit
     */
    mapping(address => bool) public _liqPairs;

    /**
     * @dev 
     * if option nSwaps -> Current number of swaps
     * if option nBlocks -> Launch block
     * if option untilTimestap -> N/A
     */
    uint256 public _disableLimitVar;
    /**
     * @dev Limits token config
     */
    DisableLimitsConfig public _disableLimitsConfig;

    /**
     * @dev Max tx amount in tokens
     */
    uint256 public _maxTx; 
    /**
     * @dev Max wallet amount in tokens
     */
    uint256 public _maxWallet;    

    //#endregion

    constructor(
        BasicTokenConfig memory tokenConfig,
        TransactionsLimitsConfig memory transactionsLimitsConfig,
        DisableLimitsConfig memory disableLimitsConfig,
        DEXConfig memory dexConfig,
        address gasGov
    ) HyperBlastStandardToken00(tokenConfig, gasGov) {      
        _supplyReceiver = tokenConfig.supplyReceiver;

        _maxTx = totalSupply() * transactionsLimitsConfig.maxTxPc / 100;
        _maxWallet = totalSupply() * transactionsLimitsConfig.maxWalletPc / 100;

        _disableLimitsConfig = disableLimitsConfig;
        if(disableLimitsConfig.disableLimitOption == DisableLimitOption.nBlocks) {
            _disableLimitVar = block.number;
        }

        address _liqPair = IHyperBlastV2Factory(IHyperBlastV2Router02(dexConfig.router).factory()).createPair(address(this), dexConfig.tokenLiq);
        _liqPairs[_liqPair] = true;

        _initialized = true;
    }

    //#region Admin    

    /**
     * This function is required to ensure all liq pairs: are exempt from limits
     * @param _adr pair address
     * @param _isLiqPair  liq pair
     */
    function setLiqPair(address _adr, bool _isLiqPair) external onlyOwner {
        require(Address.isContract(_adr), "Only liquidity pairs...");
        _liqPairs[_adr] = _isLiqPair;
    }

    /**
     * This function can be used to create liquidity pairs in others uniswapv2 forks
     * @param _adr address from uniswapv2 fork router
     * @param _adrLiq address of the token you want to use as liq pair
     */
    function createLiqPair(address _adr, address _adrLiq) external onlyOwner {
        address _liqPair = IHyperBlastV2Factory(IHyperBlastV2Router02(_adr).factory()).createPair(address(this), _adrLiq);
        _liqPairs[_liqPair] = true;
    }

    //endregion

    //#region Limits checks

    /**
     * @dev Basic behaviour when
     * 1. Contract is not initialized 
     * 2. Sender/Receiver is the supply receiver, he has to manage the whole supply, add liquidity... etc
     * 3. Sender/Receiver is the own contract, internal readjustments, tax swapbacks and buybacks in childs if exists... etc
     * Can be overriden
     */
    function onlyBasicTransfer(address from, address to) internal virtual view returns (bool) {
        return 
            !_initialized || 
            from == _supplyReceiver || 
            to == _supplyReceiver || 
            from == address(this) || 
            to == address(this) ||
            to == owner() ||
            from == owner(); 
    }

    function limitsEnabled() internal view returns (bool) {
        DisableLimitOption __disableLimitOption = _disableLimitsConfig.disableLimitOption;
        if(__disableLimitOption == DisableLimitOption.none) {
            return false;
        }

        uint256 __disableLimitBound = _disableLimitsConfig.disableLimitBound;        
        if(__disableLimitOption == DisableLimitOption.nSwaps) {
            return _disableLimitVar < __disableLimitBound;
        }
        if(__disableLimitOption == DisableLimitOption.untilTimestap) {
            return block.timestamp < __disableLimitBound;
        }
        if(__disableLimitOption == DisableLimitOption.nBlocks) {
            return block.number < (_disableLimitVar + __disableLimitBound);
        }
        
        return false;
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {
        if(onlyBasicTransfer(from, to)) return;

        //Are limits still enabled?
        bool _limitsEnabled = limitsEnabled();

        //Check limits
        if(_limitsEnabled && _maxTx > 0) {
            require(amount <= _maxTx, "You can not exceed max transaction");
        }
        if(_limitsEnabled && _maxWallet > 0 && !_liqPairs[to]) {
            require((balanceOf(to) + amount) <= _maxWallet, "Receiver can not exceed max wallet");
        }   

        //To extend
        _beforeTokenTransfer2(from, to, amount);
    }    

    function _afterTokenTransfer(address from, address to, uint256 amount) internal override {
        if(onlyBasicTransfer(from, to)) return;

        //After swap
        if(_disableLimitsConfig.disableLimitOption == DisableLimitOption.nSwaps) {
            _disableLimitVar++;
        }

        //To extend
        _afterTokenTransfer2(from, to, amount);
    }

    /*solhint-disable no-empty-blocks*/

    function _beforeTokenTransfer2(address from, address to, uint256 amount) internal virtual { }

    function _afterTokenTransfer2(address from, address to, uint256 amount) internal virtual { }

    //#endregion
}

/* solhint-disable */
interface IHyperBlastV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

/* solhint-disable */
interface IHyperBlastV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

/* solhint-disable */
import { IHyperBlastV2Router01 } from "./IHyperBlastV2Router01.sol";

interface IHyperBlastV2Router02 is IHyperBlastV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

{
  "evmVersion": "istanbul",
  "optimizer": {
    "enabled": true,
    "runs": 999
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint8","name":"tokenDecimals","type":"uint8"},{"internalType":"uint256","name":"initialSupply","type":"uint256"},{"internalType":"address","name":"supplyReceiver","type":"address"}],"internalType":"struct BasicTokenConfig","name":"tokenConfig","type":"tuple"},{"internalType":"address","name":"gasGov","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"blastOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimMax","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_claimMax","type":"bool"}],"name":"claimMode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dayCounter","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxGasForCall","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxRefund","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minRefundmentPercentage","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refundmentPercentage","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnerUpdateRefundment","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceUpdateRefundment","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_blastOwner","type":"address"}],"name":"setBlastOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxGas","type":"uint256"}],"name":"setMaxGasForCall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxRefund","type":"uint256"}],"name":"setMaxRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unstuckETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"newRFPC","type":"uint8"}],"name":"updateRefundmentPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x6080604052600436106101d15760003560e01c80638da5cb5b116100f7578063ac7c19ed11610095578063dd62ed3e11610064578063dd62ed3e14610564578063e0f2a4ce146105aa578063f2fde38b146105cb578063fcdebcce146105eb57600080fd5b8063ac7c19ed146104e2578063b2c1f98714610502578063cc08c09314610523578063d077c79f1461054357600080fd5b8063a4473c7d116100d1578063a4473c7d14610462578063a457c2d714610482578063a6142112146104a2578063a9059cbb146104c257600080fd5b80638da5cb5b146103d157806395d89b411461040357806399332c5e1461041857600080fd5b806337c349dc1161016f57806366577a351161013e57806366577a351461035c57806370a0823114610371578063715018a6146103a757806382bcedb5146103bc57600080fd5b806337c349dc146102f057806339509351146103115780634e71d92d146103315780635490822a1461034657600080fd5b80632053f300116101ab5780632053f300146102575780632353464c1461027957806323b872dd1461028f578063313ce567146102af57600080fd5b806306fdde03146101dd578063095ea7b31461020857806318160ddd1461023857600080fd5b366101d857005b600080fd5b3480156101e957600080fd5b506101f261060b565b6040516101ff9190611714565b60405180910390f35b34801561021457600080fd5b50610228610223366004611763565b61069d565b60405190151581526020016101ff565b34801561024457600080fd5b506002545b6040519081526020016101ff565b34801561026357600080fd5b5061027761027236600461178d565b6106b7565b005b34801561028557600080fd5b5061024960095481565b34801561029b57600080fd5b506102286102aa3660046117b6565b61076b565b3480156102bb57600080fd5b507f00000000000000000000000000000000000000000000000000000000000000125b60405160ff90911681526020016101ff565b3480156102fc57600080fd5b5060065461022890600160c81b900460ff1681565b34801561031d57600080fd5b5061022861032c366004611763565b61078f565b34801561033d57600080fd5b506102496107ce565b34801561035257600080fd5b5061024960085481565b34801561036857600080fd5b50610277610856565b34801561037d57600080fd5b5061024961038c3660046117f2565b6001600160a01b031660009081526020819052604090205490565b3480156103b357600080fd5b50610277610956565b3480156103c857600080fd5b5061027761096a565b3480156103dd57600080fd5b506005546001600160a01b03165b6040516001600160a01b0390911681526020016101ff565b34801561040f57600080fd5b506101f2610a1c565b34801561042457600080fd5b5060065461044e90760100000000000000000000000000000000000000000000900462ffffff1681565b60405162ffffff90911681526020016101ff565b34801561046e57600080fd5b5061027761047d36600461180d565b610a2b565b34801561048e57600080fd5b5061022861049d366004611763565b610c10565b3480156104ae57600080fd5b506102776104bd3660046117f2565b610cba565b3480156104ce57600080fd5b506102286104dd366004611763565b610d5f565b3480156104ee57600080fd5b506102776104fd366004611830565b610d6d565b34801561050e57600080fd5b506006546102de90600160a01b900460ff1681565b34801561052f57600080fd5b5061027761053e366004611830565b610e40565b34801561054f57600080fd5b5060075461022890600160a01b900460ff1681565b34801561057057600080fd5b5061024961057f366004611849565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3480156105b657600080fd5b506006546102de90600160a81b900460ff1681565b3480156105d757600080fd5b506102776105e63660046117f2565b610ebb565b3480156105f757600080fd5b506007546103eb906001600160a01b031681565b60606003805461061a9061187c565b80601f01602080910402602001604051908101604052809291908181526020018280546106469061187c565b80156106935780601f1061066857610100808354040283529160200191610693565b820191906000526020600020905b81548152906001019060200180831161067657829003601f168201915b5050505050905090565b6000336106ab818585610f48565b60019150505b92915050565b6007546001600160a01b031633146107325760405162461bcd60e51b815260206004820152603360248201527f4f6e6c7920626c61737420636f6e7472616374206f776e65722063616e206d616044820152726e61676520626c61737420666561747572657360681b60648201526084015b60405180910390fd5b60068054911515600160c81b027fffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffff909216919091179055565b6000336107798582856110a0565b610784858585611132565b506001949350505050565b3360008181526001602090815260408083206001600160a01b03871684529091528120549091906106ab90829086906107c99087906118cc565b610f48565b6007546000906001600160a01b031633146108475760405162461bcd60e51b815260206004820152603360248201527f4f6e6c7920626c61737420636f6e7472616374206f776e65722063616e206d616044820152726e61676520626c61737420666561747572657360681b6064820152608401610729565b610851600061131f565b905090565b6007546001600160a01b031633146108cc5760405162461bcd60e51b815260206004820152603360248201527f4f6e6c7920626c61737420636f6e7472616374206f776e65722063616e206d616044820152726e61676520626c61737420666561747572657360681b6064820152608401610729565b600754600160a01b900460ff16156109265760405162461bcd60e51b815260206004820152601160248201527f416c72656164792072656e6f756e6365640000000000000000000000000000006044820152606401610729565b600780547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16600160a01b179055565b61095e611637565b6109686000611691565b565b6007546001600160a01b031633146109e05760405162461bcd60e51b815260206004820152603360248201527f4f6e6c7920626c61737420636f6e7472616374206f776e65722063616e206d616044820152726e61676520626c61737420666561747572657360681b6064820152608401610729565b6007546040516001600160a01b03909116904780156108fc02916000818181858888f19350505050158015610a19573d6000803e3d6000fd5b50565b60606004805461061a9061187c565b6007546001600160a01b03163314610aa15760405162461bcd60e51b815260206004820152603360248201527f4f6e6c7920626c61737420636f6e7472616374206f776e65722063616e206d616044820152726e61676520626c61737420666561747572657360681b6064820152608401610729565b600754600160a01b900460ff1615610afb5760405162461bcd60e51b815260206004820152601360248201527f55504441544553204e4f5420414c4c4f574544000000000000000000000000006044820152606401610729565b60065460ff600160a01b90910481169082161015610b815760405162461bcd60e51b815260206004820152603460248201527f4d696e2e2067617320666f7220726566756e646d656e742068617320746f206260448201527f65206269676765722074616e206d696e696d616c0000000000000000000000006064820152608401610729565b60648160ff161115610bd55760405162461bcd60e51b815260206004820152601f60248201527f4d61782e2067617320666f7220726566756e646d656e742069732031303025006044820152606401610729565b6006805460ff909216600160a81b027fffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffffff909216919091179055565b3360008181526001602090815260408083206001600160a01b038716845290915281205490919083811015610cad5760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f0000000000000000000000000000000000000000000000000000006064820152608401610729565b6107848286868403610f48565b6007546001600160a01b03163314610d305760405162461bcd60e51b815260206004820152603360248201527f4f6e6c7920626c61737420636f6e7472616374206f776e65722063616e206d616044820152726e61676520626c61737420666561747572657360681b6064820152608401610729565b6007805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0392909216919091179055565b6000336106ab818585611132565b6007546001600160a01b03163314610de35760405162461bcd60e51b815260206004820152603360248201527f4f6e6c7920626c61737420636f6e7472616374206f776e65722063616e206d616044820152726e61676520626c61737420666561747572657360681b6064820152608401610729565b6706f05b59d3b20000811115610e3b5760405162461bcd60e51b815260206004820152601260248201527f496e76616c6964206d617820726566756e6400000000000000000000000000006044820152606401610729565b600955565b6007546001600160a01b03163314610eb65760405162461bcd60e51b815260206004820152603360248201527f4f6e6c7920626c61737420636f6e7472616374206f776e65722063616e206d616044820152726e61676520626c61737420666561747572657360681b6064820152608401610729565b600855565b610ec3611637565b6001600160a01b038116610f3f5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f64647265737300000000000000000000000000000000000000000000000000006064820152608401610729565b610a1981611691565b6001600160a01b038316610fc35760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f72657373000000000000000000000000000000000000000000000000000000006064820152608401610729565b6001600160a01b03821661103f5760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f73730000000000000000000000000000000000000000000000000000000000006064820152608401610729565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6001600160a01b03838116600090815260016020908152604080832093861683529290522054600019811461112c578181101561111f5760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152606401610729565b61112c8484848403610f48565b50505050565b6001600160a01b0383166111ae5760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f64726573730000000000000000000000000000000000000000000000000000006064820152608401610729565b6001600160a01b03821661122a5760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f65737300000000000000000000000000000000000000000000000000000000006064820152608401610729565b6001600160a01b038316600090815260208190526040902054818110156112b95760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e636500000000000000000000000000000000000000000000000000006064820152608401610729565b6001600160a01b03848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a361112c565b600047821561146357600654600090600160c81b900460ff16611362577f954fa5ee27c88a83eb6bac45faf9bf17dcbde40e107ff03508bd32ccc1f6243f611384565b7f662aa11dd0fb432d1e6c8fbc219a0b95da9ba58f40d5be8cf7968ed00b4f7ab65b6040513060248201819052604482015260640160408051601f198184030181529181526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009094169390931790925260065460085492519193506001600160a01b031691906114179084906118df565b60006040518083038160008787f1925050503d8060008114611455576040519150601f19603f3d011682016040523d82523d6000602084013e61145a565b606091505b50505050611599565b600654600160c81b900460ff1615611509576006546040517f662aa11d000000000000000000000000000000000000000000000000000000008152306004820181905260248201526001600160a01b039091169063662aa11d906044016020604051808303816000875af11580156114df573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061150391906118fb565b50611599565b6006546040517f954fa5ee000000000000000000000000000000000000000000000000000000008152306004820181905260248201526001600160a01b039091169063954fa5ee906044016020604051808303816000875af1158015611573573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061159791906118fb565b505b60065447906064600160a81b90910460ff161080156115b757508181115b1561162d576006546000906064906115d990600160a81b900460ff1682611914565b60ff166115e6858561192d565b6115f09190611940565b6115fa9190611957565b6007546040519192506001600160a01b03169082156108fc029083906000818181858888f1509398975050505050505050565b5060009392505050565b6005546001600160a01b031633146109685760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610729565b600580546001600160a01b0383811673ffffffffffffffffffffffffffffffffffffffff19831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60005b8381101561170b5781810151838201526020016116f3565b50506000910152565b60208152600082518060208401526117338160408501602087016116f0565b601f01601f19169190910160400192915050565b80356001600160a01b038116811461175e57600080fd5b919050565b6000806040838503121561177657600080fd5b61177f83611747565b946020939093013593505050565b60006020828403121561179f57600080fd5b813580151581146117af57600080fd5b9392505050565b6000806000606084860312156117cb57600080fd5b6117d484611747565b92506117e260208501611747565b9150604084013590509250925092565b60006020828403121561180457600080fd5b6117af82611747565b60006020828403121561181f57600080fd5b813560ff811681146117af57600080fd5b60006020828403121561184257600080fd5b5035919050565b6000806040838503121561185c57600080fd5b61186583611747565b915061187360208401611747565b90509250929050565b600181811c9082168061189057607f821691505b6020821081036118b057634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b808201808211156106b1576106b16118b6565b600082516118f18184602087016116f0565b9190910192915050565b60006020828403121561190d57600080fd5b5051919050565b60ff82811682821603908111156106b1576106b16118b6565b818103818111156106b1576106b16118b6565b80820281158282048414176106b1576106b16118b6565b60008261197457634e487b7160e01b600052601260045260246000fd5b50049056fea2646970667358221220e2442a1764abe5e29d489664a6cf33eb1208105d01d9606f7b2e2fc1059700ea64736f6c63430008140033

0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000873bb0d0c630cbfcecff71b6d2dec7d1dc7a740600000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000003b9aca00000000000000000000000000873bb0d0c630cbfcecff71b6d2dec7d1dc7a74060000000000000000000000000000000000000000000000000000000000000005636861736500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000056368617365000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : tokenConfig (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
Arg [1] : gasGov (address): 0x873BB0D0C630CBFCEcFf71b6D2Dec7D1DC7A7406

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 000000000000000000000000873bb0d0c630cbfcecff71b6d2dec7d1dc7a7406
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [5] : 000000000000000000000000000000000000000000000000000000003b9aca00
Arg [6] : 000000000000000000000000873bb0d0c630cbfcecff71b6d2dec7d1dc7a7406
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [8] : 6368617365000000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [10] : 6368617365000000000000000000000000000000000000000000000000000000

597:682:22:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2158:98:3;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4444:197;;;;;;;;;;-1:-1:-1;4444:197:3;;;;;:::i;:::-;;:::i;:::-;;;1295:14:27;;1288:22;1270:41;;1258:2;1243:18;4444:197:3;1130:187:27;3255:106:3;;;;;;;;;;-1:-1:-1;3342:12:3;;3255:106;;;1468:25:27;;;1456:2;1441:18;3255:106:3;1322:177:27;4965:98:8;;;;;;;;;;-1:-1:-1;4965:98:8;;;;;:::i;:::-;;:::i;:::-;;1981:37;;;;;;;;;;;;;;;;5203:256:3;;;;;;;;;;-1:-1:-1;5203:256:3;;;;;:::i;:::-;;:::i;1148:91:22:-;;;;;;;;;;-1:-1:-1;1222:9:22;1148:91;;;2287:4:27;2275:17;;;2257:36;;2245:2;2230:18;1148:91:22;2115:184:27;1466:27:8;;;;;;;;;;-1:-1:-1;1466:27:8;;;;-1:-1:-1;;;1466:27:8;;;;;;5854:234:3;;;;;;;;;;-1:-1:-1;5854:234:3;;;;;:::i;:::-;;:::i;5766:99:8:-;;;;;;;;;;;;;:::i;1855:37::-;;;;;;;;;;;;;;;;5450:181;;;;;;;;;;;;;:::i;3419:125:3:-;;;;;;;;;;-1:-1:-1;3419:125:3;;;;;:::i;:::-;-1:-1:-1;;;;;3519:18:3;3493:7;3519:18;;;;;;;;;;;;3419:125;1824:101:0;;;;;;;;;;;;;:::i;4544:116:8:-;;;;;;;;;;;;;:::i;1201:85:0:-;;;;;;;;;;-1:-1:-1;1273:6:0;;-1:-1:-1;;;;;1273:6:0;1201:85;;;-1:-1:-1;;;;;2659:55:27;;;2641:74;;2629:2;2614:18;1201:85:0;2495:226:27;2369:102:3;;;;;;;;;;;;;:::i;1361:28:8:-;;;;;;;;;;-1:-1:-1;1361:28:8;;;;;;;;;;;;;;2900:8:27;2888:21;;;2870:40;;2858:2;2843:18;1361:28:8;2726:190:27;5071:371:8;;;;;;;;;;-1:-1:-1;5071:371:8;;;;;:::i;:::-;;:::i;6575:427:3:-;;;;;;;;;;-1:-1:-1;6575:427:3;;;;;:::i;:::-;;:::i;4427:109:8:-;;;;;;;;;;-1:-1:-1;4427:109:8;;;;;:::i;:::-;;:::i;3740:189:3:-;;;;;;;;;;-1:-1:-1;3740:189:3;;;;;:::i;:::-;;:::i;4785:172:8:-;;;;;;;;;;-1:-1:-1;4785:172:8;;;;;:::i;:::-;;:::i;1128:40::-;;;;;;;;;;-1:-1:-1;1128:40:8;;;;-1:-1:-1;;;1128:40:8;;;;;;4668:109;;;;;;;;;;-1:-1:-1;4668:109:8;;;;;:::i;:::-;;:::i;1729:44::-;;;;;;;;;;-1:-1:-1;1729:44:8;;;;-1:-1:-1;;;1729:44:8;;;;;;3987:149:3;;;;;;;;;;-1:-1:-1;3987:149:3;;;;;:::i;:::-;-1:-1:-1;;;;;4102:18:3;;;4076:7;4102:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3987:149;1251:37:8;;;;;;;;;;-1:-1:-1;1251:37:8;;;;-1:-1:-1;;;1251:37:8;;;;;;2074:198:0;;;;;;;;;;-1:-1:-1;2074:198:0;;;;;:::i;:::-;;:::i;1607:25:8:-;;;;;;;;;;-1:-1:-1;1607:25:8;;;;-1:-1:-1;;;;;1607:25:8;;;2158:98:3;2212:13;2244:5;2237:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2158:98;:::o;4444:197::-;4527:4;719:10:7;4581:32:3;719:10:7;4597:7:3;4606:6;4581:8;:32::i;:::-;4630:4;4623:11;;;4444:197;;;;;:::o;4965:98:8:-;2086:10;;-1:-1:-1;;;;;2086:10:8;2072;:24;2064:88;;;;-1:-1:-1;;;2064:88:8;;4289:2:27;2064:88:8;;;4271:21:27;4328:2;4308:18;;;4301:30;4367:34;4347:18;;;4340:62;-1:-1:-1;;;4418:18:27;;;4411:49;4477:19;;2064:88:8;;;;;;;;;5035:8:::1;:20:::0;;;::::1;;-1:-1:-1::0;;;5035:20:8::1;::::0;;;::::1;::::0;;;::::1;::::0;;4965:98::o;5203:256:3:-;5300:4;719:10:7;5356:38:3;5372:4;719:10:7;5387:6:3;5356:15;:38::i;:::-;5404:27;5414:4;5420:2;5424:6;5404:9;:27::i;:::-;-1:-1:-1;5448:4:3;;5203:256;-1:-1:-1;;;;5203:256:3:o;5854:234::-;719:10:7;5942:4:3;4102:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;4102:27:3;;;;;;;;;;5942:4;;719:10:7;5996:64:3;;719:10:7;;4102:27:3;;6021:38;;6049:10;;6021:38;:::i;:::-;5996:8;:64::i;5766:99:8:-;2086:10;;5815:7;;-1:-1:-1;;;;;2086:10:8;2072;:24;2064:88;;;;-1:-1:-1;;;2064:88:8;;4289:2:27;2064:88:8;;;4271:21:27;4328:2;4308:18;;;4301:30;4367:34;4347:18;;;4340:62;-1:-1:-1;;;4418:18:27;;;4411:49;4477:19;;2064:88:8;4087:415:27;2064:88:8;5842:15:::1;5851:5;5842:8;:15::i;:::-;5835:22;;5766:99:::0;:::o;5450:181::-;2086:10;;-1:-1:-1;;;;;2086:10:8;2072;:24;2064:88;;;;-1:-1:-1;;;2064:88:8;;4289:2:27;2064:88:8;;;4271:21:27;4328:2;4308:18;;;4301:30;4367:34;4347:18;;;4340:62;-1:-1:-1;;;4418:18:27;;;4411:49;4477:19;;2064:88:8;4087:415:27;2064:88:8;5535:24:::1;::::0;-1:-1:-1;;;5535:24:8;::::1;;;5534:25;5526:55;;;::::0;-1:-1:-1;;;5526:55:8;;5028:2:27;5526:55:8::1;::::0;::::1;5010:21:27::0;5067:2;5047:18;;;5040:30;5106:19;5086:18;;;5079:47;5143:18;;5526:55:8::1;4826:341:27::0;5526:55:8::1;5592:24;:31:::0;;;::::1;-1:-1:-1::0;;;5592:31:8::1;::::0;;5450:181::o;1824:101:0:-;1094:13;:11;:13::i;:::-;1888:30:::1;1915:1;1888:18;:30::i;:::-;1824:101::o:0;4544:116:8:-;2086:10;;-1:-1:-1;;;;;2086:10:8;2072;:24;2064:88;;;;-1:-1:-1;;;2064:88:8;;4289:2:27;2064:88:8;;;4271:21:27;4328:2;4308:18;;;4301:30;4367:34;4347:18;;;4340:62;-1:-1:-1;;;4418:18:27;;;4411:49;4477:19;;2064:88:8;4087:415:27;2064:88:8;4609:10:::1;::::0;4601:51:::1;::::0;-1:-1:-1;;;;;4609:10:8;;::::1;::::0;4630:21:::1;4601:51:::0;::::1;;;::::0;4609:10:::1;4601:51:::0;4609:10;4601:51;4630:21;4609:10;4601:51;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;4544:116::o:0;2369:102:3:-;2425:13;2457:7;2450:14;;;;;:::i;5071:371:8:-;2086:10;;-1:-1:-1;;;;;2086:10:8;2072;:24;2064:88;;;;-1:-1:-1;;;2064:88:8;;4289:2:27;2064:88:8;;;4271:21:27;4328:2;4308:18;;;4301:30;4367:34;4347:18;;;4340:62;-1:-1:-1;;;4418:18:27;;;4411:49;4477:19;;2064:88:8;4087:415:27;2064:88:8;5166:24:::1;::::0;-1:-1:-1;;;5166:24:8;::::1;;;5165:25;5157:57;;;::::0;-1:-1:-1;;;5157:57:8;;5374:2:27;5157:57:8::1;::::0;::::1;5356:21:27::0;5413:2;5393:18;;;5386:30;5452:21;5432:18;;;5425:49;5491:18;;5157:57:8::1;5172:343:27::0;5157:57:8::1;5244:23;::::0;::::1;-1:-1:-1::0;;;5244:23:8;;::::1;::::0;::::1;5233:34:::0;;::::1;;;5225:99;;;::::0;-1:-1:-1;;;5225:99:8;;5722:2:27;5225:99:8::1;::::0;::::1;5704:21:27::0;5761:2;5741:18;;;5734:30;5800:34;5780:18;;;5773:62;5871:22;5851:18;;;5844:50;5911:19;;5225:99:8::1;5520:416:27::0;5225:99:8::1;5354:3;5343:7;:14;;;;5335:58;;;::::0;-1:-1:-1;;;5335:58:8;;6143:2:27;5335:58:8::1;::::0;::::1;6125:21:27::0;6182:2;6162:18;;;6155:30;6221:33;6201:18;;;6194:61;6272:18;;5335:58:8::1;5941:355:27::0;5335:58:8::1;5404:20;:30:::0;;::::1;::::0;;::::1;-1:-1:-1::0;;;5404:30:8::1;::::0;;;::::1;::::0;;;::::1;::::0;;5071:371::o;6575:427:3:-;719:10:7;6668:4:3;4102:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;4102:27:3;;;;;;;;;;6668:4;;719:10:7;6812:15:3;6792:16;:35;;6784:85;;;;-1:-1:-1;;;6784:85:3;;6503:2:27;6784:85:3;;;6485:21:27;6542:2;6522:18;;;6515:30;6581:34;6561:18;;;6554:62;6652:7;6632:18;;;6625:35;6677:19;;6784:85:3;6301:401:27;6784:85:3;6903:60;6912:5;6919:7;6947:15;6928:16;:34;6903:8;:60::i;4427:109:8:-;2086:10;;-1:-1:-1;;;;;2086:10:8;2072;:24;2064:88;;;;-1:-1:-1;;;2064:88:8;;4289:2:27;2064:88:8;;;4271:21:27;4328:2;4308:18;;;4301:30;4367:34;4347:18;;;4340:62;-1:-1:-1;;;4418:18:27;;;4411:49;4477:19;;2064:88:8;4087:415:27;2064:88:8;4504:10:::1;:24:::0;;-1:-1:-1;;4504:24:8::1;-1:-1:-1::0;;;;;4504:24:8;;;::::1;::::0;;;::::1;::::0;;4427:109::o;3740:189:3:-;3819:4;719:10:7;3873:28:3;719:10:7;3890:2:3;3894:6;3873:9;:28::i;4785:172:8:-;2086:10;;-1:-1:-1;;;;;2086:10:8;2072;:24;2064:88;;;;-1:-1:-1;;;2064:88:8;;4289:2:27;2064:88:8;;;4271:21:27;4328:2;4308:18;;;4301:30;4367:34;4347:18;;;4340:62;-1:-1:-1;;;4418:18:27;;;4411:49;4477:19;;2064:88:8;4087:415:27;2064:88:8;4884:9:::1;4870:10;:23;;4862:54;;;::::0;-1:-1:-1;;;4862:54:8;;6909:2:27;4862:54:8::1;::::0;::::1;6891:21:27::0;6948:2;6928:18;;;6921:30;6987:20;6967:18;;;6960:48;7025:18;;4862:54:8::1;6707:342:27::0;4862:54:8::1;4927:9;:22:::0;4785:172::o;4668:109::-;2086:10;;-1:-1:-1;;;;;2086:10:8;2072;:24;2064:88;;;;-1:-1:-1;;;2064:88:8;;4289:2:27;2064:88:8;;;4271:21:27;4328:2;4308:18;;;4301:30;4367:34;4347:18;;;4340:62;-1:-1:-1;;;4418:18:27;;;4411:49;4477:19;;2064:88:8;4087:415:27;2064:88:8;4746:13:::1;:23:::0;4668:109::o;2074:198:0:-;1094:13;:11;:13::i;:::-;-1:-1:-1;;;;;2162:22:0;::::1;2154:73;;;::::0;-1:-1:-1;;;2154:73:0;;7256:2:27;2154:73:0::1;::::0;::::1;7238:21:27::0;7295:2;7275:18;;;7268:30;7334:34;7314:18;;;7307:62;7405:8;7385:18;;;7378:36;7431:19;;2154:73:0::1;7054:402:27::0;2154:73:0::1;2237:28;2256:8;2237:18;:28::i;10457:340:3:-:0;-1:-1:-1;;;;;10558:19:3;;10550:68;;;;-1:-1:-1;;;10550:68:3;;7663:2:27;10550:68:3;;;7645:21:27;7702:2;7682:18;;;7675:30;7741:34;7721:18;;;7714:62;7812:6;7792:18;;;7785:34;7836:19;;10550:68:3;7461:400:27;10550:68:3;-1:-1:-1;;;;;10636:21:3;;10628:68;;;;-1:-1:-1;;;10628:68:3;;8068:2:27;10628:68:3;;;8050:21:27;8107:2;8087:18;;;8080:30;8146:34;8126:18;;;8119:62;8217:4;8197:18;;;8190:32;8239:19;;10628:68:3;7866:398:27;10628:68:3;-1:-1:-1;;;;;10707:18:3;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10758:32;;1468:25:27;;;10758:32:3;;1441:18:27;10758:32:3;;;;;;;10457:340;;;:::o;11078:411::-;-1:-1:-1;;;;;4102:18:3;;;11178:24;4102:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;11244:37:3;;11240:243;;11325:6;11305:16;:26;;11297:68;;;;-1:-1:-1;;;11297:68:3;;8471:2:27;11297:68:3;;;8453:21:27;8510:2;8490:18;;;8483:30;8549:31;8529:18;;;8522:59;8598:18;;11297:68:3;8269:353:27;11297:68:3;11407:51;11416:5;11423:7;11451:6;11432:16;:25;11407:8;:51::i;:::-;11168:321;11078:411;;;:::o;7456:788::-;-1:-1:-1;;;;;7552:18:3;;7544:68;;;;-1:-1:-1;;;7544:68:3;;8829:2:27;7544:68:3;;;8811:21:27;8868:2;8848:18;;;8841:30;8907:34;8887:18;;;8880:62;8978:7;8958:18;;;8951:35;9003:19;;7544:68:3;8627:401:27;7544:68:3;-1:-1:-1;;;;;7630:16:3;;7622:64;;;;-1:-1:-1;;;7622:64:3;;9235:2:27;7622:64:3;;;9217:21:27;9274:2;9254:18;;;9247:30;9313:34;9293:18;;;9286:62;9384:5;9364:18;;;9357:33;9407:19;;7622:64:3;9033:399:27;7622:64:3;-1:-1:-1;;;;;7768:15:3;;7746:19;7768:15;;;;;;;;;;;7801:21;;;;7793:72;;;;-1:-1:-1;;;7793:72:3;;9639:2:27;7793:72:3;;;9621:21:27;9678:2;9658:18;;;9651:30;9717:34;9697:18;;;9690:62;9788:8;9768:18;;;9761:36;9814:19;;7793:72:3;9437:402:27;7793:72:3;-1:-1:-1;;;;;7899:15:3;;;:9;:15;;;;;;;;;;;7917:20;;;7899:38;;8114:13;;;;;;;;;;:23;;;;;;8163:26;;1468:25:27;;;8114:13:3;;8163:26;;1441:18:27;8163:26:3;;;;;;;8200:37;12073:91;3371:914:8;3421:7;3459:21;3491:460;;;;3569:8;;3519:24;;-1:-1:-1;;;3569:8:8;;;;:52;;984:41;3569:52;;;882:41;3569:52;3546:106;;3631:4;3546:106;;;10079:34:27;;;10129:18;;;10122:43;9991:18;;3546:106:8;;;-1:-1:-1;;3546:106:8;;;;;;;;;;;;;;;;;;;;;;;;;;;3675:6;;3694:13;;3667:55;;3546:106;;-1:-1:-1;;;;;;3675:6:8;;3694:13;3667:55;;3546:106;;3667:55;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3504:230;3491:460;;;3758:8;;-1:-1:-1;;;3758:8:8;;;;3755:185;;;3787:6;;:48;;;;;3814:4;3787:48;;;10079:34:27;;;10129:18;;;10122:43;-1:-1:-1;;;;;3787:6:8;;;;:18;;9991::27;;3787:48:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3755:185;;;3876:6;;:48;;;;;3903:4;3876:48;;;10079:34:27;;;10129:18;;;10122:43;-1:-1:-1;;;;;3876:6:8;;;;:18;;9991::27;;3876:48:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3755:185;4015:20;;3980:21;;4038:3;-1:-1:-1;;;4015:20:8;;;;;:26;:48;;;;;4056:7;4045:8;:18;4015:48;4012:247;;;4133:20;;4080;;4157:3;;4127:26;;-1:-1:-1;;;4133:20:8;;;;4157:3;4127:26;:::i;:::-;4103:51;;4104:18;4115:7;4104:8;:18;:::i;:::-;4103:51;;;;:::i;:::-;:57;;;;:::i;:::-;4183:10;;4175:38;;4080:80;;-1:-1:-1;;;;;;4183:10:8;;4175:38;;;;;4080:80;;4183:10;4175:38;4183:10;4175:38;4080:80;4183:10;4175:38;;-1:-1:-1;4235:12:8;;3371:914;-1:-1:-1;;;;;;;;3371:914:8:o;4012:247::-;-1:-1:-1;4276:1:8;;3371:914;-1:-1:-1;;;3371:914:8:o;1359:130:0:-;1273:6;;-1:-1:-1;;;;;1273:6:0;719:10:7;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;11600:2:27;1414:68:0;;;11582:21:27;;;11619:18;;;11612:30;11678:34;11658:18;;;11651:62;11730:18;;1414:68:0;11398:356:27;2426:187:0;2518:6;;;-1:-1:-1;;;;;2534:17:0;;;-1:-1:-1;;2534:17:0;;;;;;;2566:40;;2518:6;;;2534:17;2518:6;;2566:40;;2499:16;;2566:40;2489:124;2426:187;:::o;14:250:27:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:27;238:16;;231:27;14:250::o;269:396::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;649:2;628:15;-1:-1:-1;;624:29:27;609:45;;;;656:2;605:54;;269:396;-1:-1:-1;;269:396:27:o;670:196::-;738:20;;-1:-1:-1;;;;;787:54:27;;777:65;;767:93;;856:1;853;846:12;767:93;670:196;;;:::o;871:254::-;939:6;947;1000:2;988:9;979:7;975:23;971:32;968:52;;;1016:1;1013;1006:12;968:52;1039:29;1058:9;1039:29;:::i;:::-;1029:39;1115:2;1100:18;;;;1087:32;;-1:-1:-1;;;871:254:27:o;1504:273::-;1560:6;1613:2;1601:9;1592:7;1588:23;1584:32;1581:52;;;1629:1;1626;1619:12;1581:52;1668:9;1655:23;1721:5;1714:13;1707:21;1700:5;1697:32;1687:60;;1743:1;1740;1733:12;1687:60;1766:5;1504:273;-1:-1:-1;;;1504:273:27:o;1782:328::-;1859:6;1867;1875;1928:2;1916:9;1907:7;1903:23;1899:32;1896:52;;;1944:1;1941;1934:12;1896:52;1967:29;1986:9;1967:29;:::i;:::-;1957:39;;2015:38;2049:2;2038:9;2034:18;2015:38;:::i;:::-;2005:48;;2100:2;2089:9;2085:18;2072:32;2062:42;;1782:328;;;;;:::o;2304:186::-;2363:6;2416:2;2404:9;2395:7;2391:23;2387:32;2384:52;;;2432:1;2429;2422:12;2384:52;2455:29;2474:9;2455:29;:::i;2921:269::-;2978:6;3031:2;3019:9;3010:7;3006:23;3002:32;2999:52;;;3047:1;3044;3037:12;2999:52;3086:9;3073:23;3136:4;3129:5;3125:16;3118:5;3115:27;3105:55;;3156:1;3153;3146:12;3195:180;3254:6;3307:2;3295:9;3286:7;3282:23;3278:32;3275:52;;;3323:1;3320;3313:12;3275:52;-1:-1:-1;3346:23:27;;3195:180;-1:-1:-1;3195:180:27:o;3380:260::-;3448:6;3456;3509:2;3497:9;3488:7;3484:23;3480:32;3477:52;;;3525:1;3522;3515:12;3477:52;3548:29;3567:9;3548:29;:::i;:::-;3538:39;;3596:38;3630:2;3619:9;3615:18;3596:38;:::i;:::-;3586:48;;3380:260;;;;;:::o;3645:437::-;3724:1;3720:12;;;;3767;;;3788:61;;3842:4;3834:6;3830:17;3820:27;;3788:61;3895:2;3887:6;3884:14;3864:18;3861:38;3858:218;;-1:-1:-1;;;3929:1:27;3922:88;4033:4;4030:1;4023:15;4061:4;4058:1;4051:15;3858:218;;3645:437;;;:::o;4507:184::-;-1:-1:-1;;;4556:1:27;4549:88;4656:4;4653:1;4646:15;4680:4;4677:1;4670:15;4696:125;4761:9;;;4782:10;;;4779:36;;;4795:18;;:::i;10176:287::-;10305:3;10343:6;10337:13;10359:66;10418:6;10413:3;10406:4;10398:6;10394:17;10359:66;:::i;:::-;10441:16;;;;;10176:287;-1:-1:-1;;10176:287:27:o;10468:184::-;10538:6;10591:2;10579:9;10570:7;10566:23;10562:32;10559:52;;;10607:1;10604;10597:12;10559:52;-1:-1:-1;10630:16:27;;10468:184;-1:-1:-1;10468:184:27:o;10657:151::-;10747:4;10740:12;;;10726;;;10722:31;;10765:14;;10762:40;;;10782:18;;:::i;10813:128::-;10880:9;;;10901:11;;;10898:37;;;10915:18;;:::i;10946:168::-;11019:9;;;11050;;11067:15;;;11061:22;;11047:37;11037:71;;11088:18;;:::i;11119:274::-;11159:1;11185;11175:189;;-1:-1:-1;;;11217:1:27;11210:88;11321:4;11318:1;11311:15;11349:4;11346:1;11339:15;11175:189;-1:-1:-1;11378:9:27;;11119:274::o

ipfs://e2442a1764abe5e29d489664a6cf33eb1208105d01d9606f7b2e2fc1059700ea