text: """Generated wrapper for ContractMetadataRegistry Solidity contract."""
  
  # pylint: disable=too-many-arguments
  
  import json
  from typing import (  # pylint: disable=unused-import
      Any,
      List,
      Optional,
      Tuple,
      Union,
  )
  
  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 zero_ex.contract_wrappers.bases import ContractMethod, Validator
  from zero_ex.contract_wrappers.tx_params import TxParams
  
  
  # 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 ContractMetadataRegistry 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
          ContractMetadataRegistryValidator,
      )
  except ImportError:
  
      class ContractMetadataRegistryValidator(Validator):  # type: ignore
          """No-op input validator."""
  
  
  try:
      from .middleware import MIDDLEWARE  # type: ignore
  except ImportError:
      pass
  
  
  class DefaultAdminRoleMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the DEFAULT_ADMIN_ROLE method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address)
          self._underlying_method = contract_function
  
      def call(self, tx_params: Optional[TxParams] = None) -> Union[bytes, str]:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method().call(tx_params.as_dict())
          return Union[bytes, str](returned)
  
      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 OperatorRoleMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the OPERATOR_ROLE method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address)
          self._underlying_method = contract_function
  
      def call(self, tx_params: Optional[TxParams] = None) -> Union[bytes, str]:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method().call(tx_params.as_dict())
          return Union[bytes, str](returned)
  
      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 GetMetadataUriMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the getMetadataUri method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(self, index_0: str):
          """Validate the inputs to the getMetadataUri method."""
          self.validator.assert_valid(
              method_name="getMetadataUri",
              parameter_name="index_0",
              argument_value=index_0,
          )
          index_0 = self.validate_and_checksum_address(index_0)
          return index_0
  
      def call(self, index_0: str, tx_params: Optional[TxParams] = None) -> str:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (index_0) = self.validate_and_normalize_inputs(index_0)
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method(index_0).call(tx_params.as_dict())
          return str(returned)
  
      def send_transaction(
          self, index_0: str, tx_params: Optional[TxParams] = None
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (index_0) = self.validate_and_normalize_inputs(index_0)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(index_0).transact(tx_params.as_dict())
  
      def build_transaction(
          self, index_0: str, tx_params: Optional[TxParams] = None
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (index_0) = self.validate_and_normalize_inputs(index_0)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(index_0).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self, index_0: str, tx_params: Optional[TxParams] = None
      ) -> int:
          """Estimate gas consumption of method call."""
          (index_0) = self.validate_and_normalize_inputs(index_0)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(index_0).estimateGas(
              tx_params.as_dict()
          )
  
  
  class GetRoleAdminMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the getRoleAdmin method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(self, role: Union[bytes, str]):
          """Validate the inputs to the getRoleAdmin method."""
          self.validator.assert_valid(
              method_name="getRoleAdmin",
              parameter_name="role",
              argument_value=role,
          )
          return role
  
      def call(
          self, role: Union[bytes, str], tx_params: Optional[TxParams] = None
      ) -> Union[bytes, str]:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (role) = self.validate_and_normalize_inputs(role)
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method(role).call(tx_params.as_dict())
          return Union[bytes, str](returned)
  
      def send_transaction(
          self, role: Union[bytes, str], tx_params: Optional[TxParams] = None
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (role) = self.validate_and_normalize_inputs(role)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role).transact(tx_params.as_dict())
  
      def build_transaction(
          self, role: Union[bytes, str], tx_params: Optional[TxParams] = None
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (role) = self.validate_and_normalize_inputs(role)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self, role: Union[bytes, str], tx_params: Optional[TxParams] = None
      ) -> int:
          """Estimate gas consumption of method call."""
          (role) = self.validate_and_normalize_inputs(role)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role).estimateGas(tx_params.as_dict())
  
  
  class GetRoleMemberMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the getRoleMember method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(
          self, role: Union[bytes, str], index: int
      ):
          """Validate the inputs to the getRoleMember method."""
          self.validator.assert_valid(
              method_name="getRoleMember",
              parameter_name="role",
              argument_value=role,
          )
          self.validator.assert_valid(
              method_name="getRoleMember",
              parameter_name="index",
              argument_value=index,
          )
          # safeguard against fractional inputs
          index = int(index)
          return (role, index)
  
      def call(
          self,
          role: Union[bytes, str],
          index: int,
          tx_params: Optional[TxParams] = None,
      ) -> str:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (role, index) = self.validate_and_normalize_inputs(role, index)
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method(role, index).call(
              tx_params.as_dict()
          )
          return str(returned)
  
      def send_transaction(
          self,
          role: Union[bytes, str],
          index: int,
          tx_params: Optional[TxParams] = None,
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (role, index) = self.validate_and_normalize_inputs(role, index)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, index).transact(
              tx_params.as_dict()
          )
  
      def build_transaction(
          self,
          role: Union[bytes, str],
          index: int,
          tx_params: Optional[TxParams] = None,
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (role, index) = self.validate_and_normalize_inputs(role, index)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, index).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self,
          role: Union[bytes, str],
          index: int,
          tx_params: Optional[TxParams] = None,
      ) -> int:
          """Estimate gas consumption of method call."""
          (role, index) = self.validate_and_normalize_inputs(role, index)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, index).estimateGas(
              tx_params.as_dict()
          )
  
  
  class GetRoleMemberCountMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the getRoleMemberCount method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(self, role: Union[bytes, str]):
          """Validate the inputs to the getRoleMemberCount method."""
          self.validator.assert_valid(
              method_name="getRoleMemberCount",
              parameter_name="role",
              argument_value=role,
          )
          return role
  
      def call(
          self, role: Union[bytes, str], tx_params: Optional[TxParams] = None
      ) -> int:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (role) = self.validate_and_normalize_inputs(role)
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method(role).call(tx_params.as_dict())
          return int(returned)
  
      def send_transaction(
          self, role: Union[bytes, str], tx_params: Optional[TxParams] = None
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (role) = self.validate_and_normalize_inputs(role)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role).transact(tx_params.as_dict())
  
      def build_transaction(
          self, role: Union[bytes, str], tx_params: Optional[TxParams] = None
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (role) = self.validate_and_normalize_inputs(role)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self, role: Union[bytes, str], tx_params: Optional[TxParams] = None
      ) -> int:
          """Estimate gas consumption of method call."""
          (role) = self.validate_and_normalize_inputs(role)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role).estimateGas(tx_params.as_dict())
  
  
  class GrantRoleMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the grantRole method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(
          self, role: Union[bytes, str], account: str
      ):
          """Validate the inputs to the grantRole method."""
          self.validator.assert_valid(
              method_name="grantRole",
              parameter_name="role",
              argument_value=role,
          )
          self.validator.assert_valid(
              method_name="grantRole",
              parameter_name="account",
              argument_value=account,
          )
          account = self.validate_and_checksum_address(account)
          return (role, account)
  
      def call(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> None:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          self._underlying_method(role, account).call(tx_params.as_dict())
  
      def send_transaction(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).transact(
              tx_params.as_dict()
          )
  
      def build_transaction(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> int:
          """Estimate gas consumption of method call."""
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).estimateGas(
              tx_params.as_dict()
          )
  
  
  class HasRoleMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the hasRole method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(
          self, role: Union[bytes, str], account: str
      ):
          """Validate the inputs to the hasRole method."""
          self.validator.assert_valid(
              method_name="hasRole",
              parameter_name="role",
              argument_value=role,
          )
          self.validator.assert_valid(
              method_name="hasRole",
              parameter_name="account",
              argument_value=account,
          )
          account = self.validate_and_checksum_address(account)
          return (role, account)
  
      def call(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> bool:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method(role, account).call(
              tx_params.as_dict()
          )
          return bool(returned)
  
      def send_transaction(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).transact(
              tx_params.as_dict()
          )
  
      def build_transaction(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> int:
          """Estimate gas consumption of method call."""
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).estimateGas(
              tx_params.as_dict()
          )
  
  
  class IsTrustedForwarderMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the isTrustedForwarder method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(self, forwarder: str):
          """Validate the inputs to the isTrustedForwarder method."""
          self.validator.assert_valid(
              method_name="isTrustedForwarder",
              parameter_name="forwarder",
              argument_value=forwarder,
          )
          forwarder = self.validate_and_checksum_address(forwarder)
          return forwarder
  
      def call(
          self, forwarder: str, tx_params: Optional[TxParams] = None
      ) -> bool:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (forwarder) = self.validate_and_normalize_inputs(forwarder)
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method(forwarder).call(tx_params.as_dict())
          return bool(returned)
  
      def send_transaction(
          self, forwarder: str, tx_params: Optional[TxParams] = None
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (forwarder) = self.validate_and_normalize_inputs(forwarder)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(forwarder).transact(tx_params.as_dict())
  
      def build_transaction(
          self, forwarder: str, tx_params: Optional[TxParams] = None
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (forwarder) = self.validate_and_normalize_inputs(forwarder)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(forwarder).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self, forwarder: str, tx_params: Optional[TxParams] = None
      ) -> int:
          """Estimate gas consumption of method call."""
          (forwarder) = self.validate_and_normalize_inputs(forwarder)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(forwarder).estimateGas(
              tx_params.as_dict()
          )
  
  
  class MulticallMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the multicall method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(self, data: List[Union[bytes, str]]):
          """Validate the inputs to the multicall method."""
          self.validator.assert_valid(
              method_name="multicall",
              parameter_name="data",
              argument_value=data,
          )
          return data
  
      def call(
          self,
          data: List[Union[bytes, str]],
          tx_params: Optional[TxParams] = None,
      ) -> List[Union[bytes, str]]:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (data) = self.validate_and_normalize_inputs(data)
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method(data).call(tx_params.as_dict())
          return [Union[bytes, str](element) for element in returned]
  
      def send_transaction(
          self,
          data: List[Union[bytes, str]],
          tx_params: Optional[TxParams] = None,
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (data) = self.validate_and_normalize_inputs(data)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(data).transact(tx_params.as_dict())
  
      def build_transaction(
          self,
          data: List[Union[bytes, str]],
          tx_params: Optional[TxParams] = None,
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (data) = self.validate_and_normalize_inputs(data)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(data).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self,
          data: List[Union[bytes, str]],
          tx_params: Optional[TxParams] = None,
      ) -> int:
          """Estimate gas consumption of method call."""
          (data) = self.validate_and_normalize_inputs(data)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(data).estimateGas(tx_params.as_dict())
  
  
  class RegisterMetadataMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the registerMetadata method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(
          self, contract_address: str, metadata_uri: str
      ):
          """Validate the inputs to the registerMetadata method."""
          self.validator.assert_valid(
              method_name="registerMetadata",
              parameter_name="contractAddress",
              argument_value=contract_address,
          )
          contract_address = self.validate_and_checksum_address(contract_address)
          self.validator.assert_valid(
              method_name="registerMetadata",
              parameter_name="metadataUri",
              argument_value=metadata_uri,
          )
          return (contract_address, metadata_uri)
  
      def call(
          self,
          contract_address: str,
          metadata_uri: str,
          tx_params: Optional[TxParams] = None,
      ) -> None:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (contract_address, metadata_uri) = self.validate_and_normalize_inputs(
              contract_address, metadata_uri
          )
          tx_params = super().normalize_tx_params(tx_params)
          self._underlying_method(contract_address, metadata_uri).call(
              tx_params.as_dict()
          )
  
      def send_transaction(
          self,
          contract_address: str,
          metadata_uri: str,
          tx_params: Optional[TxParams] = None,
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (contract_address, metadata_uri) = self.validate_and_normalize_inputs(
              contract_address, metadata_uri
          )
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(
              contract_address, metadata_uri
          ).transact(tx_params.as_dict())
  
      def build_transaction(
          self,
          contract_address: str,
          metadata_uri: str,
          tx_params: Optional[TxParams] = None,
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (contract_address, metadata_uri) = self.validate_and_normalize_inputs(
              contract_address, metadata_uri
          )
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(
              contract_address, metadata_uri
          ).buildTransaction(tx_params.as_dict())
  
      def estimate_gas(
          self,
          contract_address: str,
          metadata_uri: str,
          tx_params: Optional[TxParams] = None,
      ) -> int:
          """Estimate gas consumption of method call."""
          (contract_address, metadata_uri) = self.validate_and_normalize_inputs(
              contract_address, metadata_uri
          )
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(
              contract_address, metadata_uri
          ).estimateGas(tx_params.as_dict())
  
  
  class RenounceRoleMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the renounceRole method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(
          self, role: Union[bytes, str], account: str
      ):
          """Validate the inputs to the renounceRole method."""
          self.validator.assert_valid(
              method_name="renounceRole",
              parameter_name="role",
              argument_value=role,
          )
          self.validator.assert_valid(
              method_name="renounceRole",
              parameter_name="account",
              argument_value=account,
          )
          account = self.validate_and_checksum_address(account)
          return (role, account)
  
      def call(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> None:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          self._underlying_method(role, account).call(tx_params.as_dict())
  
      def send_transaction(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).transact(
              tx_params.as_dict()
          )
  
      def build_transaction(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> int:
          """Estimate gas consumption of method call."""
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).estimateGas(
              tx_params.as_dict()
          )
  
  
  class RevokeRoleMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the revokeRole method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(
          self, role: Union[bytes, str], account: str
      ):
          """Validate the inputs to the revokeRole method."""
          self.validator.assert_valid(
              method_name="revokeRole",
              parameter_name="role",
              argument_value=role,
          )
          self.validator.assert_valid(
              method_name="revokeRole",
              parameter_name="account",
              argument_value=account,
          )
          account = self.validate_and_checksum_address(account)
          return (role, account)
  
      def call(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> None:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          self._underlying_method(role, account).call(tx_params.as_dict())
  
      def send_transaction(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).transact(
              tx_params.as_dict()
          )
  
      def build_transaction(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self,
          role: Union[bytes, str],
          account: str,
          tx_params: Optional[TxParams] = None,
      ) -> int:
          """Estimate gas consumption of method call."""
          (role, account) = self.validate_and_normalize_inputs(role, account)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(role, account).estimateGas(
              tx_params.as_dict()
          )
  
  
  class SupportsInterfaceMethod(ContractMethod):  # pylint: disable=invalid-name
      """Various interfaces to the supportsInterface method."""
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          contract_function: ContractFunction,
          validator: Validator = None,
      ):
          """Persist instance data."""
          super().__init__(web3_or_provider, contract_address, validator)
          self._underlying_method = contract_function
  
      def validate_and_normalize_inputs(self, interface_id: Union[bytes, str]):
          """Validate the inputs to the supportsInterface method."""
          self.validator.assert_valid(
              method_name="supportsInterface",
              parameter_name="interfaceId",
              argument_value=interface_id,
          )
          return interface_id
  
      def call(
          self,
          interface_id: Union[bytes, str],
          tx_params: Optional[TxParams] = None,
      ) -> bool:
          """Execute underlying contract method via eth_call.
  
          :param tx_params: transaction parameters
          :returns: the return value of the underlying method.
          """
          (interface_id) = self.validate_and_normalize_inputs(interface_id)
          tx_params = super().normalize_tx_params(tx_params)
          returned = self._underlying_method(interface_id).call(
              tx_params.as_dict()
          )
          return bool(returned)
  
      def send_transaction(
          self,
          interface_id: Union[bytes, str],
          tx_params: Optional[TxParams] = None,
      ) -> Union[HexBytes, bytes]:
          """Execute underlying contract method via eth_sendTransaction.
  
          :param tx_params: transaction parameters
          """
          (interface_id) = self.validate_and_normalize_inputs(interface_id)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(interface_id).transact(
              tx_params.as_dict()
          )
  
      def build_transaction(
          self,
          interface_id: Union[bytes, str],
          tx_params: Optional[TxParams] = None,
      ) -> dict:
          """Construct calldata to be used as input to the method."""
          (interface_id) = self.validate_and_normalize_inputs(interface_id)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(interface_id).buildTransaction(
              tx_params.as_dict()
          )
  
      def estimate_gas(
          self,
          interface_id: Union[bytes, str],
          tx_params: Optional[TxParams] = None,
      ) -> int:
          """Estimate gas consumption of method call."""
          (interface_id) = self.validate_and_normalize_inputs(interface_id)
          tx_params = super().normalize_tx_params(tx_params)
          return self._underlying_method(interface_id).estimateGas(
              tx_params.as_dict()
          )
  
  
  # pylint: disable=too-many-public-methods,too-many-instance-attributes
  class ContractMetadataRegistry:
      """Wrapper class for ContractMetadataRegistry Solidity contract."""
  
      default_admin_role: DefaultAdminRoleMethod
      """Constructor-initialized instance of
      :class:`DefaultAdminRoleMethod`.
      """
  
      operator_role: OperatorRoleMethod
      """Constructor-initialized instance of
      :class:`OperatorRoleMethod`.
      """
  
      get_metadata_uri: GetMetadataUriMethod
      """Constructor-initialized instance of
      :class:`GetMetadataUriMethod`.
      """
  
      get_role_admin: GetRoleAdminMethod
      """Constructor-initialized instance of
      :class:`GetRoleAdminMethod`.
      """
  
      get_role_member: GetRoleMemberMethod
      """Constructor-initialized instance of
      :class:`GetRoleMemberMethod`.
      """
  
      get_role_member_count: GetRoleMemberCountMethod
      """Constructor-initialized instance of
      :class:`GetRoleMemberCountMethod`.
      """
  
      grant_role: GrantRoleMethod
      """Constructor-initialized instance of
      :class:`GrantRoleMethod`.
      """
  
      has_role: HasRoleMethod
      """Constructor-initialized instance of
      :class:`HasRoleMethod`.
      """
  
      is_trusted_forwarder: IsTrustedForwarderMethod
      """Constructor-initialized instance of
      :class:`IsTrustedForwarderMethod`.
      """
  
      multicall: MulticallMethod
      """Constructor-initialized instance of
      :class:`MulticallMethod`.
      """
  
      register_metadata: RegisterMetadataMethod
      """Constructor-initialized instance of
      :class:`RegisterMetadataMethod`.
      """
  
      renounce_role: RenounceRoleMethod
      """Constructor-initialized instance of
      :class:`RenounceRoleMethod`.
      """
  
      revoke_role: RevokeRoleMethod
      """Constructor-initialized instance of
      :class:`RevokeRoleMethod`.
      """
  
      supports_interface: SupportsInterfaceMethod
      """Constructor-initialized instance of
      :class:`SupportsInterfaceMethod`.
      """
  
      def __init__(
          self,
          web3_or_provider: Union[Web3, BaseProvider],
          contract_address: str,
          validator: ContractMetadataRegistryValidator = None,
      ):
          """Get an instance of wrapper for smart contract.
  
          :param web3_or_provider: Either an instance of `web3.Web3`:code: or
              `web3.providers.base.BaseProvider`:code:
          :param contract_address: where the contract has been deployed
          :param validator: for validation of method inputs.
          """
          # pylint: disable=too-many-statements
  
          self.contract_address = contract_address
  
          if not validator:
              validator = ContractMetadataRegistryValidator(
                  web3_or_provider, contract_address
              )
  
          web3 = None
          if isinstance(web3_or_provider, BaseProvider):
              web3 = Web3(web3_or_provider)
          elif isinstance(web3_or_provider, Web3):
              web3 = web3_or_provider
          else:
              raise TypeError(
                  "Expected parameter 'web3_or_provider' to be an instance of either"
                  + " Web3 or BaseProvider"
              )
  
          # 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=ContractMetadataRegistry.abi(),
          ).functions
  
          self.default_admin_role = DefaultAdminRoleMethod(
              web3_or_provider, contract_address, functions.DEFAULT_ADMIN_ROLE
          )
  
          self.operator_role = OperatorRoleMethod(
              web3_or_provider, contract_address, functions.OPERATOR_ROLE
          )
  
          self.get_metadata_uri = GetMetadataUriMethod(
              web3_or_provider,
              contract_address,
              functions.getMetadataUri,
              validator,
          )
  
          self.get_role_admin = GetRoleAdminMethod(
              web3_or_provider,
              contract_address,
              functions.getRoleAdmin,
              validator,
          )
  
          self.get_role_member = GetRoleMemberMethod(
              web3_or_provider,
              contract_address,
              functions.getRoleMember,
              validator,
          )
  
          self.get_role_member_count = GetRoleMemberCountMethod(
              web3_or_provider,
              contract_address,
              functions.getRoleMemberCount,
              validator,
          )
  
          self.grant_role = GrantRoleMethod(
              web3_or_provider, contract_address, functions.grantRole, validator
          )
  
          self.has_role = HasRoleMethod(
              web3_or_provider, contract_address, functions.hasRole, validator
          )
  
          self.is_trusted_forwarder = IsTrustedForwarderMethod(
              web3_or_provider,
              contract_address,
              functions.isTrustedForwarder,
              validator,
          )
  
          self.multicall = MulticallMethod(
              web3_or_provider, contract_address, functions.multicall, validator
          )
  
          self.register_metadata = RegisterMetadataMethod(
              web3_or_provider,
              contract_address,
              functions.registerMetadata,
              validator,
          )
  
          self.renounce_role = RenounceRoleMethod(
              web3_or_provider,
              contract_address,
              functions.renounceRole,
              validator,
          )
  
          self.revoke_role = RevokeRoleMethod(
              web3_or_provider, contract_address, functions.revokeRole, validator
          )
  
          self.supports_interface = SupportsInterfaceMethod(
              web3_or_provider,
              contract_address,
              functions.supportsInterface,
              validator,
          )
  
      def get_metadata_registered_event(
          self, tx_hash: Union[HexBytes, bytes]
      ) -> Tuple[AttributeDict]:
          """Get log entry for MetadataRegistered event.
  
          :param tx_hash: hash of transaction emitting MetadataRegistered event
          """
          tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
          return (
              self._web3_eth.contract(
                  address=to_checksum_address(self.contract_address),
                  abi=ContractMetadataRegistry.abi(),
              )
              .events.MetadataRegistered()
              .processReceipt(tx_receipt)
          )
  
      def get_role_admin_changed_event(
          self, tx_hash: Union[HexBytes, bytes]
      ) -> Tuple[AttributeDict]:
          """Get log entry for RoleAdminChanged event.
  
          :param tx_hash: hash of transaction emitting RoleAdminChanged event
          """
          tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
          return (
              self._web3_eth.contract(
                  address=to_checksum_address(self.contract_address),
                  abi=ContractMetadataRegistry.abi(),
              )
              .events.RoleAdminChanged()
              .processReceipt(tx_receipt)
          )
  
      def get_role_granted_event(
          self, tx_hash: Union[HexBytes, bytes]
      ) -> Tuple[AttributeDict]:
          """Get log entry for RoleGranted event.
  
          :param tx_hash: hash of transaction emitting RoleGranted event
          """
          tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
          return (
              self._web3_eth.contract(
                  address=to_checksum_address(self.contract_address),
                  abi=ContractMetadataRegistry.abi(),
              )
              .events.RoleGranted()
              .processReceipt(tx_receipt)
          )
  
      def get_role_revoked_event(
          self, tx_hash: Union[HexBytes, bytes]
      ) -> Tuple[AttributeDict]:
          """Get log entry for RoleRevoked event.
  
          :param tx_hash: hash of transaction emitting RoleRevoked event
          """
          tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
          return (
              self._web3_eth.contract(
                  address=to_checksum_address(self.contract_address),
                  abi=ContractMetadataRegistry.abi(),
              )
              .events.RoleRevoked()
              .processReceipt(tx_receipt)
          )
  
      @staticmethod
      def abi():
          """Return the ABI to the underlying contract."""
          return json.loads(
              '[{"inputs":[{"internalType":"address","name":"_trustedForwarder","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"contractAddress","type":"address"},{"indexed":false,"internalType":"string","name":"metadataUri","type":"string"}],"name":"MetadataRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"index_0","type":"address"}],"name":"getMetadataUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"string","name":"metadataUri","type":"string"}],"name":"registerMetadata","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]'  # noqa: E501 (line-too-long)
          )
  
  
  # pylint: disable=too-many-lines
  