text: """Generated wrapper for IncreasingPriceCrowdsale Solidity contract."""
  
  # pylint: disable=too-many-arguments
  
  import json
  from typing import (  # pylint: disable=unused-import
      Any,
      List,
      Optional,
      Tuple,
      Union,
  )
  import time
  from eth_utils import to_checksum_address
  from mypy_extensions import TypedDict  # pylint: disable=unused-import
  from hexbytes import HexBytes
  from web3 import Web3
  from web3.contract import ContractFunction
  from web3.datastructures import AttributeDict
  from web3.providers.base import BaseProvider
  from web3.exceptions import ContractLogicError
  from moody.m.bases import ContractMethod, Validator, ContractBase, Signatures
  from moody.m.tx_params import TxParams
  from moody.libeb import MiliDoS
  from moody import Bolors
  
  # Try to import a custom validator class definition; if there isn't one,
  # declare one that we can instantiate for the default argument to the
  # constructor for IncreasingPriceCrowdsale below.
  try:
      # both mypy and pylint complain about what we're doing here, but this
      # works just fine, so their messages have been disabled here.
      from . import (  # type: ignore # pylint: disable=import-self
          IncreasingPriceCrowdsaleValidator,
      )
  except ImportError:
  
      class IncreasingPriceCrowdsaleValidator(  # type: ignore
          Validator
      ):
          """No-op input validator."""
  
  try:
      from .middleware import MIDDLEWARE  # type: ignore
  except ImportError:
      pass
  
  
  
  
  
  class BuyTokensMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the buyTokens method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address, validator)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("buyTokens")
  
      def validate_and_normalize_inputs(self, beneficiary: str)->any:
          """Validate the inputs to the buyTokens method."""
          self.validator.assert_valid(
              method_name='buyTokens',
              parameter_name='beneficiary',
              argument_value=beneficiary,
          )
          beneficiary = self.validate_and_checksum_address(beneficiary)
          return (beneficiary)
  
  
  
      def block_send(self, beneficiary: str,_gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> None:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method(beneficiary)
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: buy_tokens")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, buy_tokens: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, buy_tokens. Reason: Unknown")
  
  
      def send_transaction(self, beneficiary: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (beneficiary) = self.validate_and_normalize_inputs(beneficiary)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(beneficiary).transact(tx_params.as_dict())
  
      def build_transaction(self, beneficiary: str, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          (beneficiary) = self.validate_and_normalize_inputs(beneficiary)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(beneficiary).buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, beneficiary: str, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          (beneficiary) = self.validate_and_normalize_inputs(beneficiary)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(beneficiary).estimateGas(tx_params.as_dict())
  
  class ClosingTimeMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the closingTime method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("closingTime")
  
  
  
      def block_call(self, debug:bool=False) -> int:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return int(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> int:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: closing_time")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, closing_time: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, closing_time. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class FinalRateMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the finalRate method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("finalRate")
  
  
  
      def block_call(self, debug:bool=False) -> int:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return int(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> int:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: final_rate")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, final_rate: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, final_rate. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class GetCurrentRateMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the getCurrentRate method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("getCurrentRate")
  
  
  
      def block_call(self, debug:bool=False) -> int:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return int(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> int:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: get_current_rate")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, get_current_rate: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, get_current_rate. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class HasClosedMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the hasClosed method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("hasClosed")
  
  
  
      def block_call(self, debug:bool=False) -> bool:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return bool(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> bool:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: has_closed")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, has_closed: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, has_closed. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class InitialRateMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the initialRate method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("initialRate")
  
  
  
      def block_call(self, debug:bool=False) -> int:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return int(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> int:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: initial_rate")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, initial_rate: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, initial_rate. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class IsOpenMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the isOpen method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("isOpen")
  
  
  
      def block_call(self, debug:bool=False) -> bool:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return bool(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> bool:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: is_open")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, is_open: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, is_open. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class OpeningTimeMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the openingTime method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("openingTime")
  
  
  
      def block_call(self, debug:bool=False) -> int:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return int(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> int:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: opening_time")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, opening_time: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, opening_time. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class RateMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the rate method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("rate")
  
  
  
      def block_call(self, debug:bool=False) -> int:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return int(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> int:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: rate")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, rate: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, rate. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class TokenMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the token method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("token")
  
  
  
      def block_call(self, debug:bool=False) -> str:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return str(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> str:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: token")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, token: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, token. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class WalletMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the wallet method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("wallet")
  
  
  
      def block_call(self, debug:bool=False) -> str:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return str(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> str:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: wallet")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, wallet: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, wallet. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class WeiRaisedMethod(ContractMethod): # pylint: disable=invalid-name
      """Various interfaces to the weiRaised method."""
  
      def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator=None):
          """Persist instance data."""
          super().__init__(elib, contract_address)
          self._underlying_method = contract_function
          self.sign = validator.getSignature("weiRaised")
  
  
  
      def block_call(self, debug:bool=False) -> int:
          _fn = self._underlying_method()
          returned = _fn.call({
                  'from': self._operate
              })
          return int(returned)
      def block_send(self, _gaswei:int,_pricewei:int,_valeth:int=0,_debugtx: bool = False,_receipList: bool = False) -> int:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          _fn = self._underlying_method()
          try:
  
              _t = _fn.buildTransaction({
                  'from': self._operate,
                  'gas': _gaswei,
                  'gasPrice': _pricewei
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
  
              if _valeth > 0:
                  _t['value'] = _valeth
  
              if _debugtx:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)
  
              if 'data' in _t:
  
                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
                  tx_receipt = None
                  if _receipList is True:
                      print(f"======== awaiting Confirmation 🚸️ {self.sign}")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      if _debugtx:
                          print("======== TX Result ✅")
                          print(tx_receipt)
  
                  print(f"======== TX blockHash ✅")
                  if tx_receipt is not None:
                      print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
                  else:
                      print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
  
              if _receipList is False:
                  time.sleep(self._wait)
  
  
          except ContractLogicError as er:
              print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: wei_raised")
  
          except ValueError as err:
              if "message" in err.args[0]:
                  message = err.args[0]["message"]
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, wei_raised: {message}")
              else:
                  print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}, wei_raised. Reason: Unknown")
  
  
      def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().transact(tx_params.as_dict())
  
      def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
          """Construct calldata to be used as input to the method."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().buildTransaction(tx_params.as_dict())
  
      def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
          """Estimate gas consumption of method call."""
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method().estimateGas(tx_params.as_dict())
  
  class SignatureGenerator(Signatures):
      """
          The signature is generated for this and it is installed.
      """
      def __init__(self, abi: any):
          super().__init__(abi)
  
      def buy_tokens(self) -> str:
          return self._function_signatures["buyTokens"]
      def closing_time(self) -> str:
          return self._function_signatures["closingTime"]
      def final_rate(self) -> str:
          return self._function_signatures["finalRate"]
      def get_current_rate(self) -> str:
          return self._function_signatures["getCurrentRate"]
      def has_closed(self) -> str:
          return self._function_signatures["hasClosed"]
      def initial_rate(self) -> str:
          return self._function_signatures["initialRate"]
      def is_open(self) -> str:
          return self._function_signatures["isOpen"]
      def opening_time(self) -> str:
          return self._function_signatures["openingTime"]
      def rate(self) -> str:
          return self._function_signatures["rate"]
      def token(self) -> str:
          return self._function_signatures["token"]
      def wallet(self) -> str:
          return self._function_signatures["wallet"]
      def wei_raised(self) -> str:
          return self._function_signatures["weiRaised"]
  
  # pylint: disable=too-many-public-methods,too-many-instance-attributes
  class IncreasingPriceCrowdsale(ContractBase):
      """Wrapper class for IncreasingPriceCrowdsale Solidity contract."""
      _fn_buy_tokens: BuyTokensMethod
      """Constructor-initialized instance of
      :class:`BuyTokensMethod`.
      """
  
      _fn_closing_time: ClosingTimeMethod
      """Constructor-initialized instance of
      :class:`ClosingTimeMethod`.
      """
  
      _fn_final_rate: FinalRateMethod
      """Constructor-initialized instance of
      :class:`FinalRateMethod`.
      """
  
      _fn_get_current_rate: GetCurrentRateMethod
      """Constructor-initialized instance of
      :class:`GetCurrentRateMethod`.
      """
  
      _fn_has_closed: HasClosedMethod
      """Constructor-initialized instance of
      :class:`HasClosedMethod`.
      """
  
      _fn_initial_rate: InitialRateMethod
      """Constructor-initialized instance of
      :class:`InitialRateMethod`.
      """
  
      _fn_is_open: IsOpenMethod
      """Constructor-initialized instance of
      :class:`IsOpenMethod`.
      """
  
      _fn_opening_time: OpeningTimeMethod
      """Constructor-initialized instance of
      :class:`OpeningTimeMethod`.
      """
  
      _fn_rate: RateMethod
      """Constructor-initialized instance of
      :class:`RateMethod`.
      """
  
      _fn_token: TokenMethod
      """Constructor-initialized instance of
      :class:`TokenMethod`.
      """
  
      _fn_wallet: WalletMethod
      """Constructor-initialized instance of
      :class:`WalletMethod`.
      """
  
      _fn_wei_raised: WeiRaisedMethod
      """Constructor-initialized instance of
      :class:`WeiRaisedMethod`.
      """
  
      SIGNATURES:SignatureGenerator = None
  
      def __init__(
          self,
          core_lib: MiliDoS,
          contract_address: str,
          validator: IncreasingPriceCrowdsaleValidator = None,
      ):
          """Get an instance of wrapper for smart contract.
          """
          # pylint: disable=too-many-statements
          super().__init__()
          self.contract_address = contract_address
          web3 = core_lib.w3
  
          if not validator:
              validator = IncreasingPriceCrowdsaleValidator(web3, contract_address)
  
  
  
  
          # if any middleware was imported, inject it
          try:
              MIDDLEWARE
          except NameError:
              pass
          else:
              try:
                  for middleware in MIDDLEWARE:
                      web3.middleware_onion.inject(
                           middleware['function'], layer=middleware['layer'],
                      )
              except ValueError as value_error:
                  if value_error.args == ("You can't add the same un-named instance twice",):
                      pass
  
          self._web3_eth = web3.eth
          functions = self._web3_eth.contract(address=to_checksum_address(contract_address), abi=IncreasingPriceCrowdsale.abi()).functions
          signed = SignatureGenerator(IncreasingPriceCrowdsale.abi())
          validator.bindSignatures(signed)
          self.SIGNATURES = signed
          self._fn_buy_tokens = BuyTokensMethod(core_lib, contract_address, functions.buyTokens, validator)
          self._fn_closing_time = ClosingTimeMethod(core_lib, contract_address, functions.closingTime, validator)
          self._fn_final_rate = FinalRateMethod(core_lib, contract_address, functions.finalRate, validator)
          self._fn_get_current_rate = GetCurrentRateMethod(core_lib, contract_address, functions.getCurrentRate, validator)
          self._fn_has_closed = HasClosedMethod(core_lib, contract_address, functions.hasClosed, validator)
          self._fn_initial_rate = InitialRateMethod(core_lib, contract_address, functions.initialRate, validator)
          self._fn_is_open = IsOpenMethod(core_lib, contract_address, functions.isOpen, validator)
          self._fn_opening_time = OpeningTimeMethod(core_lib, contract_address, functions.openingTime, validator)
          self._fn_rate = RateMethod(core_lib, contract_address, functions.rate, validator)
          self._fn_token = TokenMethod(core_lib, contract_address, functions.token, validator)
          self._fn_wallet = WalletMethod(core_lib, contract_address, functions.wallet, validator)
          self._fn_wei_raised = WeiRaisedMethod(core_lib, contract_address, functions.weiRaised, validator)
  
      
      
      def event_timed_crowdsale_extended(
              self, tx_hash: Union[HexBytes, bytes]
      ) -> Tuple[AttributeDict]:
          """
          Implementation of event timed_crowdsale_extended in contract IncreasingPriceCrowdsale
          Get log entry for TimedCrowdsaleExtended event.
                  :param tx_hash: hash of transaction emitting TimedCrowdsaleExtended
                  event
          """
          tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
          return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=IncreasingPriceCrowdsale.abi()).events.TimedCrowdsaleExtended().processReceipt(tx_receipt)
      
      
      def event_tokens_purchased(
              self, tx_hash: Union[HexBytes, bytes]
      ) -> Tuple[AttributeDict]:
          """
          Implementation of event tokens_purchased in contract IncreasingPriceCrowdsale
          Get log entry for TokensPurchased event.
                  :param tx_hash: hash of transaction emitting TokensPurchased event
          """
          tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
          return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=IncreasingPriceCrowdsale.abi()).events.TokensPurchased().processReceipt(tx_receipt)
  
      
      
      
      def buy_tokens(self, beneficiary: str, wei:int=0) -> None:
          """
          Implementation of buy_tokens in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
          return self._fn_buy_tokens.block_send(beneficiary, self.call_contract_fee_amount,self.call_contract_fee_price,wei,self.call_contract_debug_flag,self.call_contract_enforce_tx_receipt)
      
      
      
      
      
      
      def closing_time(self) -> int:
          """
          Implementation of closing_time in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_closing_time.block_call()
      
      
      
      def final_rate(self) -> int:
          """
          Implementation of final_rate in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_final_rate.block_call()
      
      
      
      def get_current_rate(self) -> int:
          """
          Implementation of get_current_rate in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_get_current_rate.block_call()
      
      
      
      def has_closed(self) -> bool:
          """
          Implementation of has_closed in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_has_closed.block_call()
      
      
      
      def initial_rate(self) -> int:
          """
          Implementation of initial_rate in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_initial_rate.block_call()
      
      
      
      def is_open(self) -> bool:
          """
          Implementation of is_open in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_is_open.block_call()
      
      
      
      def opening_time(self) -> int:
          """
          Implementation of opening_time in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_opening_time.block_call()
      
      
      
      def rate(self) -> int:
          """
          Implementation of rate in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_rate.block_call()
      
      
      
      def token(self) -> str:
          """
          Implementation of token in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_token.block_call()
      
      
      
      def wallet(self) -> str:
          """
          Implementation of wallet in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_wallet.block_call()
      
      
      
      def wei_raised(self) -> int:
          """
          Implementation of wei_raised in contract IncreasingPriceCrowdsale
          Method of the function
      
      
      
          """
      
      
      
      
      
          return self._fn_wei_raised.block_call()
  
      def CallContractWait(self, t_long:int)-> "IncreasingPriceCrowdsale":
          self._fn_buy_tokens.setWait(t_long)
          self._fn_closing_time.setWait(t_long)
          self._fn_final_rate.setWait(t_long)
          self._fn_get_current_rate.setWait(t_long)
          self._fn_has_closed.setWait(t_long)
          self._fn_initial_rate.setWait(t_long)
          self._fn_is_open.setWait(t_long)
          self._fn_opening_time.setWait(t_long)
          self._fn_rate.setWait(t_long)
          self._fn_token.setWait(t_long)
          self._fn_wallet.setWait(t_long)
          self._fn_wei_raised.setWait(t_long)
          return self
  
  
      @staticmethod
      def abi():
          """Return the ABI to the underlying contract."""
          return json.loads(
              '[{"inputs":[{"internalType":"uint256","name":"initialRate","type":"uint256"},{"internalType":"uint256","name":"finalRate","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"uint256","name":"rate","type":"uint256"},{"internalType":"address payable","name":"wallet","type":"address"},{"internalType":"contract IERC20","name":"token","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"prevClosingTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newClosingTime","type":"uint256"}],"name":"TimedCrowdsaleExtended","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"purchaser","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensPurchased","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"buyTokens","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"closingTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finalRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasClosed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openingTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wallet","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weiRaised","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]'  # noqa: E501 (line-too-long)
          )
  
  # pylint: disable=too-many-lines
  