ddx-python 1.0.5__cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

ddx/rest_client/contracts/dummy_token/__init__.py

@@ -0,0 +1,1014 @@
+"""Generated wrapper for DummyToken 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.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 DummyToken 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
+        DummyTokenValidator,
+    )
+except ImportError:
+
+    class DummyTokenValidator(  # type: ignore
+        Validator
+    ):
+        """No-op input validator."""
+
+
+try:
+    from .middleware import MIDDLEWARE  # type: ignore
+except ImportError:
+    pass
+
+
+
+
+
+class AllowanceMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the allowance method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, owner: str, spender: str):
+        """Validate the inputs to the allowance method."""
+        self.validator.assert_valid(
+            method_name='allowance',
+            parameter_name='owner',
+            argument_value=owner,
+        )
+        owner = self.validate_and_checksum_address(owner)
+        self.validator.assert_valid(
+            method_name='allowance',
+            parameter_name='spender',
+            argument_value=spender,
+        )
+        spender = self.validate_and_checksum_address(spender)
+        return (owner, spender)
+
+    def call(self, owner: str, spender: str, tx_params: Optional[TxParams] = None) -> int:
+        """Execute underlying contract method via eth_call.
+
+        See {IERC20-allowance}.
+
+        :param tx_params: transaction parameters
+        :returns: the return value of the underlying method.
+        """
+        (owner, spender) = self.validate_and_normalize_inputs(owner, spender)
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method(owner, spender).call(tx_params.as_dict())
+        return int(returned)
+
+    def send_transaction(self, owner: str, spender: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        See {IERC20-allowance}.
+
+        :param tx_params: transaction parameters
+        """
+        (owner, spender) = self.validate_and_normalize_inputs(owner, spender)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(owner, spender).transact(tx_params.as_dict())
+
+    def build_transaction(self, owner: str, spender: str, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (owner, spender) = self.validate_and_normalize_inputs(owner, spender)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(owner, spender).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, owner: str, spender: str, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (owner, spender) = self.validate_and_normalize_inputs(owner, spender)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(owner, spender).estimate_gas(tx_params.as_dict())
+
+class ApproveMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the approve method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, spender: str, amount: int):
+        """Validate the inputs to the approve method."""
+        self.validator.assert_valid(
+            method_name='approve',
+            parameter_name='spender',
+            argument_value=spender,
+        )
+        spender = self.validate_and_checksum_address(spender)
+        self.validator.assert_valid(
+            method_name='approve',
+            parameter_name='amount',
+            argument_value=amount,
+        )
+        # safeguard against fractional inputs
+        amount = int(amount)
+        return (spender, amount)
+
+    def call(self, spender: str, amount: int, tx_params: Optional[TxParams] = None) -> bool:
+        """Execute underlying contract method via eth_call.
+
+        See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the
+        allowance is not updated on `transferFrom`. This is semantically
+        equivalent to an infinite approval. Requirements: - `spender` cannot be
+        the zero address.
+
+        :param tx_params: transaction parameters
+        :returns: the return value of the underlying method.
+        """
+        (spender, amount) = self.validate_and_normalize_inputs(spender, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method(spender, amount).call(tx_params.as_dict())
+        return bool(returned)
+
+    def send_transaction(self, spender: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the
+        allowance is not updated on `transferFrom`. This is semantically
+        equivalent to an infinite approval. Requirements: - `spender` cannot be
+        the zero address.
+
+        :param tx_params: transaction parameters
+        """
+        (spender, amount) = self.validate_and_normalize_inputs(spender, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, amount).transact(tx_params.as_dict())
+
+    def build_transaction(self, spender: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (spender, amount) = self.validate_and_normalize_inputs(spender, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, amount).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, spender: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (spender, amount) = self.validate_and_normalize_inputs(spender, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, amount).estimate_gas(tx_params.as_dict())
+
+class BalanceOfMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the balanceOf method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, account: str):
+        """Validate the inputs to the balanceOf method."""
+        self.validator.assert_valid(
+            method_name='balanceOf',
+            parameter_name='account',
+            argument_value=account,
+        )
+        account = self.validate_and_checksum_address(account)
+        return (account)
+
+    def call(self, account: str, tx_params: Optional[TxParams] = None) -> int:
+        """Execute underlying contract method via eth_call.
+
+        See {IERC20-balanceOf}.
+
+        :param tx_params: transaction parameters
+        :returns: the return value of the underlying method.
+        """
+        (account) = self.validate_and_normalize_inputs(account)
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method(account).call(tx_params.as_dict())
+        return int(returned)
+
+    def send_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        See {IERC20-balanceOf}.
+
+        :param tx_params: transaction parameters
+        """
+        (account) = self.validate_and_normalize_inputs(account)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account).transact(tx_params.as_dict())
+
+    def build_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (account) = self.validate_and_normalize_inputs(account)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, account: str, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (account) = self.validate_and_normalize_inputs(account)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account).estimate_gas(tx_params.as_dict())
+
+class BurnMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the burn method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, account: str, amount: int):
+        """Validate the inputs to the burn method."""
+        self.validator.assert_valid(
+            method_name='burn',
+            parameter_name='account',
+            argument_value=account,
+        )
+        account = self.validate_and_checksum_address(account)
+        self.validator.assert_valid(
+            method_name='burn',
+            parameter_name='amount',
+            argument_value=amount,
+        )
+        # safeguard against fractional inputs
+        amount = int(amount)
+        return (account, amount)
+
+    def call(self, account: str, amount: int, 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.
+        """
+        (account, amount) = self.validate_and_normalize_inputs(account, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        self._underlying_method(account, amount).call(tx_params.as_dict())
+
+    def send_transaction(self, account: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        :param tx_params: transaction parameters
+        """
+        (account, amount) = self.validate_and_normalize_inputs(account, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account, amount).transact(tx_params.as_dict())
+
+    def build_transaction(self, account: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (account, amount) = self.validate_and_normalize_inputs(account, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account, amount).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, account: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (account, amount) = self.validate_and_normalize_inputs(account, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account, amount).estimate_gas(tx_params.as_dict())
+
+class DecimalsMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the decimals method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function):
+        """Persist instance data."""
+        super().__init__(web3_or_provider, contract_address)
+        self._underlying_method = contract_function
+
+    def call(self, tx_params: Optional[TxParams] = None) -> int:
+        """Execute underlying contract method via eth_call.
+
+        Returns the number of decimals used to get its user representation. For
+        example, if `decimals` equals `2`, a balance of `505` tokens should be
+        displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for
+        a value of 18, imitating the relationship between Ether and Wei. This
+        is the default value returned by this function, unless it's overridden.
+        NOTE: This information is only used for _display_ purposes: it in no
+        way affects any of the arithmetic of the contract, including {IERC20-
+        balanceOf} and {IERC20-transfer}.
+
+        :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 int(returned)
+
+    def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        Returns the number of decimals used to get its user representation. For
+        example, if `decimals` equals `2`, a balance of `505` tokens should be
+        displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for
+        a value of 18, imitating the relationship between Ether and Wei. This
+        is the default value returned by this function, unless it's overridden.
+        NOTE: This information is only used for _display_ purposes: it in no
+        way affects any of the arithmetic of the contract, including {IERC20-
+        balanceOf} and {IERC20-transfer}.
+
+        :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().build_transaction(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().estimate_gas(tx_params.as_dict())
+
+class DecreaseAllowanceMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the decreaseAllowance method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, spender: str, subtracted_value: int):
+        """Validate the inputs to the decreaseAllowance method."""
+        self.validator.assert_valid(
+            method_name='decreaseAllowance',
+            parameter_name='spender',
+            argument_value=spender,
+        )
+        spender = self.validate_and_checksum_address(spender)
+        self.validator.assert_valid(
+            method_name='decreaseAllowance',
+            parameter_name='subtractedValue',
+            argument_value=subtracted_value,
+        )
+        # safeguard against fractional inputs
+        subtracted_value = int(subtracted_value)
+        return (spender, subtracted_value)
+
+    def call(self, spender: str, subtracted_value: int, tx_params: Optional[TxParams] = None) -> bool:
+        """Execute underlying contract method via eth_call.
+
+        Atomically decreases the allowance granted to `spender` by the caller.
+        This is an alternative to {approve} that can be used as a mitigation
+        for problems described in {IERC20-approve}. Emits an {Approval} event
+        indicating the updated allowance. Requirements: - `spender` cannot be
+        the zero address. - `spender` must have allowance for the caller of at
+        least `subtractedValue`.
+
+        :param tx_params: transaction parameters
+        :returns: the return value of the underlying method.
+        """
+        (spender, subtracted_value) = self.validate_and_normalize_inputs(spender, subtracted_value)
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method(spender, subtracted_value).call(tx_params.as_dict())
+        return bool(returned)
+
+    def send_transaction(self, spender: str, subtracted_value: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        Atomically decreases the allowance granted to `spender` by the caller.
+        This is an alternative to {approve} that can be used as a mitigation
+        for problems described in {IERC20-approve}. Emits an {Approval} event
+        indicating the updated allowance. Requirements: - `spender` cannot be
+        the zero address. - `spender` must have allowance for the caller of at
+        least `subtractedValue`.
+
+        :param tx_params: transaction parameters
+        """
+        (spender, subtracted_value) = self.validate_and_normalize_inputs(spender, subtracted_value)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, subtracted_value).transact(tx_params.as_dict())
+
+    def build_transaction(self, spender: str, subtracted_value: int, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (spender, subtracted_value) = self.validate_and_normalize_inputs(spender, subtracted_value)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, subtracted_value).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, spender: str, subtracted_value: int, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (spender, subtracted_value) = self.validate_and_normalize_inputs(spender, subtracted_value)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, subtracted_value).estimate_gas(tx_params.as_dict())
+
+class IncreaseAllowanceMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the increaseAllowance method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, spender: str, added_value: int):
+        """Validate the inputs to the increaseAllowance method."""
+        self.validator.assert_valid(
+            method_name='increaseAllowance',
+            parameter_name='spender',
+            argument_value=spender,
+        )
+        spender = self.validate_and_checksum_address(spender)
+        self.validator.assert_valid(
+            method_name='increaseAllowance',
+            parameter_name='addedValue',
+            argument_value=added_value,
+        )
+        # safeguard against fractional inputs
+        added_value = int(added_value)
+        return (spender, added_value)
+
+    def call(self, spender: str, added_value: int, tx_params: Optional[TxParams] = None) -> bool:
+        """Execute underlying contract method via eth_call.
+
+        Atomically increases the allowance granted to `spender` by the caller.
+        This is an alternative to {approve} that can be used as a mitigation
+        for problems described in {IERC20-approve}. Emits an {Approval} event
+        indicating the updated allowance. Requirements: - `spender` cannot be
+        the zero address.
+
+        :param tx_params: transaction parameters
+        :returns: the return value of the underlying method.
+        """
+        (spender, added_value) = self.validate_and_normalize_inputs(spender, added_value)
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method(spender, added_value).call(tx_params.as_dict())
+        return bool(returned)
+
+    def send_transaction(self, spender: str, added_value: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        Atomically increases the allowance granted to `spender` by the caller.
+        This is an alternative to {approve} that can be used as a mitigation
+        for problems described in {IERC20-approve}. Emits an {Approval} event
+        indicating the updated allowance. Requirements: - `spender` cannot be
+        the zero address.
+
+        :param tx_params: transaction parameters
+        """
+        (spender, added_value) = self.validate_and_normalize_inputs(spender, added_value)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, added_value).transact(tx_params.as_dict())
+
+    def build_transaction(self, spender: str, added_value: int, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (spender, added_value) = self.validate_and_normalize_inputs(spender, added_value)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, added_value).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, spender: str, added_value: int, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (spender, added_value) = self.validate_and_normalize_inputs(spender, added_value)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(spender, added_value).estimate_gas(tx_params.as_dict())
+
+class InitialSupplyMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the initialSupply method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function):
+        """Persist instance data."""
+        super().__init__(web3_or_provider, contract_address)
+        self._underlying_method = contract_function
+
+    def call(self, 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.
+        """
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method().call(tx_params.as_dict())
+        return int(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().build_transaction(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().estimate_gas(tx_params.as_dict())
+
+class MintMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the mint method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, account: str, amount: int):
+        """Validate the inputs to the mint method."""
+        self.validator.assert_valid(
+            method_name='mint',
+            parameter_name='account',
+            argument_value=account,
+        )
+        account = self.validate_and_checksum_address(account)
+        self.validator.assert_valid(
+            method_name='mint',
+            parameter_name='amount',
+            argument_value=amount,
+        )
+        # safeguard against fractional inputs
+        amount = int(amount)
+        return (account, amount)
+
+    def call(self, account: str, amount: int, 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.
+        """
+        (account, amount) = self.validate_and_normalize_inputs(account, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        self._underlying_method(account, amount).call(tx_params.as_dict())
+
+    def send_transaction(self, account: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        :param tx_params: transaction parameters
+        """
+        (account, amount) = self.validate_and_normalize_inputs(account, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account, amount).transact(tx_params.as_dict())
+
+    def build_transaction(self, account: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (account, amount) = self.validate_and_normalize_inputs(account, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account, amount).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, account: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (account, amount) = self.validate_and_normalize_inputs(account, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(account, amount).estimate_gas(tx_params.as_dict())
+
+class NameMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the name method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function):
+        """Persist instance data."""
+        super().__init__(web3_or_provider, contract_address)
+        self._underlying_method = contract_function
+
+    def call(self, tx_params: Optional[TxParams] = None) -> str:
+        """Execute underlying contract method via eth_call.
+
+        Returns the name of the token.
+
+        :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 str(returned)
+
+    def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        Returns the name of the token.
+
+        :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().build_transaction(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().estimate_gas(tx_params.as_dict())
+
+class SymbolMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the symbol method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function):
+        """Persist instance data."""
+        super().__init__(web3_or_provider, contract_address)
+        self._underlying_method = contract_function
+
+    def call(self, tx_params: Optional[TxParams] = None) -> str:
+        """Execute underlying contract method via eth_call.
+
+        Returns the symbol of the token, usually a shorter version of the name.
+
+        :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 str(returned)
+
+    def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        Returns the symbol of the token, usually a shorter version of the name.
+
+        :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().build_transaction(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().estimate_gas(tx_params.as_dict())
+
+class TotalSupplyMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the totalSupply method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function):
+        """Persist instance data."""
+        super().__init__(web3_or_provider, contract_address)
+        self._underlying_method = contract_function
+
+    def call(self, tx_params: Optional[TxParams] = None) -> int:
+        """Execute underlying contract method via eth_call.
+
+        See {IERC20-totalSupply}.
+
+        :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 int(returned)
+
+    def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        See {IERC20-totalSupply}.
+
+        :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().build_transaction(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().estimate_gas(tx_params.as_dict())
+
+class TransferMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the transfer method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, to: str, amount: int):
+        """Validate the inputs to the transfer method."""
+        self.validator.assert_valid(
+            method_name='transfer',
+            parameter_name='to',
+            argument_value=to,
+        )
+        to = self.validate_and_checksum_address(to)
+        self.validator.assert_valid(
+            method_name='transfer',
+            parameter_name='amount',
+            argument_value=amount,
+        )
+        # safeguard against fractional inputs
+        amount = int(amount)
+        return (to, amount)
+
+    def call(self, to: str, amount: int, tx_params: Optional[TxParams] = None) -> bool:
+        """Execute underlying contract method via eth_call.
+
+        See {IERC20-transfer}. Requirements: - `to` cannot be the zero address.
+        - the caller must have a balance of at least `amount`.
+
+        :param tx_params: transaction parameters
+        :returns: the return value of the underlying method.
+        """
+        (to, amount) = self.validate_and_normalize_inputs(to, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method(to, amount).call(tx_params.as_dict())
+        return bool(returned)
+
+    def send_transaction(self, to: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        See {IERC20-transfer}. Requirements: - `to` cannot be the zero address.
+        - the caller must have a balance of at least `amount`.
+
+        :param tx_params: transaction parameters
+        """
+        (to, amount) = self.validate_and_normalize_inputs(to, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(to, amount).transact(tx_params.as_dict())
+
+    def build_transaction(self, to: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (to, amount) = self.validate_and_normalize_inputs(to, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(to, amount).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, to: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (to, amount) = self.validate_and_normalize_inputs(to, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(to, amount).estimate_gas(tx_params.as_dict())
+
+class TransferFromMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the transferFrom method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function, 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, _from: str, to: str, amount: int):
+        """Validate the inputs to the transferFrom method."""
+        self.validator.assert_valid(
+            method_name='transferFrom',
+            parameter_name='from',
+            argument_value=_from,
+        )
+        _from = self.validate_and_checksum_address(_from)
+        self.validator.assert_valid(
+            method_name='transferFrom',
+            parameter_name='to',
+            argument_value=to,
+        )
+        to = self.validate_and_checksum_address(to)
+        self.validator.assert_valid(
+            method_name='transferFrom',
+            parameter_name='amount',
+            argument_value=amount,
+        )
+        # safeguard against fractional inputs
+        amount = int(amount)
+        return (_from, to, amount)
+
+    def call(self, _from: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> bool:
+        """Execute underlying contract method via eth_call.
+
+        See {IERC20-transferFrom}. Emits an {Approval} event indicating the
+        updated allowance. This is not required by the EIP. See the note at the
+        beginning of {ERC20}. NOTE: Does not update the allowance if the
+        current allowance is the maximum `uint256`. Requirements: - `from` and
+        `to` cannot be the zero address. - `from` must have a balance of at
+        least `amount`. - the caller must have allowance for ``from``'s tokens
+        of at least `amount`.
+
+        :param tx_params: transaction parameters
+        :returns: the return value of the underlying method.
+        """
+        (_from, to, amount) = self.validate_and_normalize_inputs(_from, to, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method(_from, to, amount).call(tx_params.as_dict())
+        return bool(returned)
+
+    def send_transaction(self, _from: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        See {IERC20-transferFrom}. Emits an {Approval} event indicating the
+        updated allowance. This is not required by the EIP. See the note at the
+        beginning of {ERC20}. NOTE: Does not update the allowance if the
+        current allowance is the maximum `uint256`. Requirements: - `from` and
+        `to` cannot be the zero address. - `from` must have a balance of at
+        least `amount`. - the caller must have allowance for ``from``'s tokens
+        of at least `amount`.
+
+        :param tx_params: transaction parameters
+        """
+        (_from, to, amount) = self.validate_and_normalize_inputs(_from, to, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(_from, to, amount).transact(tx_params.as_dict())
+
+    def build_transaction(self, _from: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (_from, to, amount) = self.validate_and_normalize_inputs(_from, to, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(_from, to, amount).build_transaction(tx_params.as_dict())
+
+    def estimate_gas(self, _from: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (_from, to, amount) = self.validate_and_normalize_inputs(_from, to, amount)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(_from, to, amount).estimate_gas(tx_params.as_dict())
+
+# pylint: disable=too-many-public-methods,too-many-instance-attributes
+class DummyToken:
+    """Wrapper class for DummyToken Solidity contract."""
+    allowance: AllowanceMethod
+    """Constructor-initialized instance of
+    :class:`AllowanceMethod`.
+    """
+
+    approve: ApproveMethod
+    """Constructor-initialized instance of
+    :class:`ApproveMethod`.
+    """
+
+    balance_of: BalanceOfMethod
+    """Constructor-initialized instance of
+    :class:`BalanceOfMethod`.
+    """
+
+    burn: BurnMethod
+    """Constructor-initialized instance of
+    :class:`BurnMethod`.
+    """
+
+    decimals: DecimalsMethod
+    """Constructor-initialized instance of
+    :class:`DecimalsMethod`.
+    """
+
+    decrease_allowance: DecreaseAllowanceMethod
+    """Constructor-initialized instance of
+    :class:`DecreaseAllowanceMethod`.
+    """
+
+    increase_allowance: IncreaseAllowanceMethod
+    """Constructor-initialized instance of
+    :class:`IncreaseAllowanceMethod`.
+    """
+
+    initial_supply: InitialSupplyMethod
+    """Constructor-initialized instance of
+    :class:`InitialSupplyMethod`.
+    """
+
+    mint: MintMethod
+    """Constructor-initialized instance of
+    :class:`MintMethod`.
+    """
+
+    name: NameMethod
+    """Constructor-initialized instance of
+    :class:`NameMethod`.
+    """
+
+    symbol: SymbolMethod
+    """Constructor-initialized instance of
+    :class:`SymbolMethod`.
+    """
+
+    total_supply: TotalSupplyMethod
+    """Constructor-initialized instance of
+    :class:`TotalSupplyMethod`.
+    """
+
+    transfer: TransferMethod
+    """Constructor-initialized instance of
+    :class:`TransferMethod`.
+    """
+
+    transfer_from: TransferFromMethod
+    """Constructor-initialized instance of
+    :class:`TransferFromMethod`.
+    """
+
+
+    def __init__(
+        self,
+        web3_or_provider: Union[Web3, BaseProvider],
+        contract_address: str,
+        validator: DummyTokenValidator = 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 = DummyTokenValidator(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=DummyToken.abi()).functions
+
+        self.allowance = AllowanceMethod(web3_or_provider, contract_address, functions.allowance, validator)
+
+        self.approve = ApproveMethod(web3_or_provider, contract_address, functions.approve, validator)
+
+        self.balance_of = BalanceOfMethod(web3_or_provider, contract_address, functions.balanceOf, validator)
+
+        self.burn = BurnMethod(web3_or_provider, contract_address, functions.burn, validator)
+
+        self.decimals = DecimalsMethod(web3_or_provider, contract_address, functions.decimals)
+
+        self.decrease_allowance = DecreaseAllowanceMethod(web3_or_provider, contract_address, functions.decreaseAllowance, validator)
+
+        self.increase_allowance = IncreaseAllowanceMethod(web3_or_provider, contract_address, functions.increaseAllowance, validator)
+
+        self.initial_supply = InitialSupplyMethod(web3_or_provider, contract_address, functions.initialSupply)
+
+        self.mint = MintMethod(web3_or_provider, contract_address, functions.mint, validator)
+
+        self.name = NameMethod(web3_or_provider, contract_address, functions.name)
+
+        self.symbol = SymbolMethod(web3_or_provider, contract_address, functions.symbol)
+
+        self.total_supply = TotalSupplyMethod(web3_or_provider, contract_address, functions.totalSupply)
+
+        self.transfer = TransferMethod(web3_or_provider, contract_address, functions.transfer, validator)
+
+        self.transfer_from = TransferFromMethod(web3_or_provider, contract_address, functions.transferFrom, validator)
+
+    def get_approval_event(
+        self, tx_hash: Union[HexBytes, bytes]
+    ) -> Tuple[AttributeDict]:
+        """Get log entry for Approval event.
+
+        :param tx_hash: hash of transaction emitting Approval event
+        """
+        tx_receipt = self._web3_eth.get_transaction_receipt(tx_hash)
+        return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=DummyToken.abi()).events.Approval().process_receipt(tx_receipt)
+    def get_transfer_event(
+        self, tx_hash: Union[HexBytes, bytes]
+    ) -> Tuple[AttributeDict]:
+        """Get log entry for Transfer event.
+
+        :param tx_hash: hash of transaction emitting Transfer event
+        """
+        tx_receipt = self._web3_eth.get_transaction_receipt(tx_hash)
+        return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=DummyToken.abi()).events.Transfer().process_receipt(tx_receipt)
+
+    @staticmethod
+    def abi():
+        """Return the ABI to the underlying contract."""
+        return json.loads(
+            '[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initialSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]'  # noqa: E501 (line-too-long)
+        )
+
+# pylint: disable=too-many-lines