moody.m.erc20 API documentation
Description: Generated wrapper for Ori20 Solidity contract.

# Module `moody.m.erc20`

Generated wrapper for Ori20 Solidity contract.

Expand source code

    """Generated wrapper for Ori20 Solidity contract."""

    # pylint: disable=too-many-arguments

    import json
    from typing import (  # pylint: disable=unused-import
        Optional,
        Tuple,
        Union,
    )

    from eth_utils import to_checksum_address
    from hexbytes import HexBytes
    from web3.contract import ContractFunction
    from web3.datastructures import AttributeDict

    from ..bases import ContractMethod, Validator
    from ..tx_params import TxParams
    from ...libeb import MiliDoS

    # 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 Ori20 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
            Ori20Validator,
        )
    except ImportError:

        class Ori20Validator(  # type: ignore
            Validator
        ):
            """No-op input validator."""

    try:
        from .middleware import MIDDLEWARE  # type: ignore
    except ImportError:
        pass

    class AddMinterMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the addMinter method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        def validate_and_normalize_inputs(self, account: str):
            """Validate the inputs to the addMinter method."""
            self.validator.assert_valid(
                method_name='addMinter',
                parameter_name='account',
                argument_value=account,
            )
            account = self.validate_and_checksum_address(account)
            return (account)

        def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (account) = self.validate_and_normalize_inputs(account)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            self._underlying_method(account).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        def send_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :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).buildTransaction(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).estimateGas(tx_params.as_dict())

    class AllowanceMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the allowance method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        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 block_call(self, owner: str, spender: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            (owner, spender) = self.validate_and_normalize_inputs(owner, spender)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(owner, spender).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(owner, spender)

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

        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).estimateGas(tx_params.as_dict())

    class ApproveMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the approve method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        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 block_call(self, spender: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (spender, amount) = self.validate_and_normalize_inputs(spender, amount)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(spender, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(spender, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        def send_transaction(self, spender: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :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).buildTransaction(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).estimateGas(tx_params.as_dict())

    class BalanceOfMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the balanceOf method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        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 block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            (account) = self.validate_and_normalize_inputs(account)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(account).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account)

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

        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).estimateGas(tx_params.as_dict())

    class BurnMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the burn method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        def validate_and_normalize_inputs(self, amount: int):
            """Validate the inputs to the burn method."""
            self.validator.assert_valid(
                method_name='burn',
                parameter_name='amount',
                argument_value=amount,
            )
            # safeguard against fractional inputs
            amount = int(amount)
            return (amount)

        def block_call(self, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (amount) = self.validate_and_normalize_inputs(amount)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            self._underlying_method(amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        def send_transaction(self, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :param tx_params: transaction parameters
            """
            (amount) = self.validate_and_normalize_inputs(amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(amount).transact(tx_params.as_dict())

        def build_transaction(self, amount: int, tx_params: Optional[TxParams] = None) -> dict:
            """Construct calldata to be used as input to the method."""
            (amount) = self.validate_and_normalize_inputs(amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(amount).buildTransaction(tx_params.as_dict())

        def estimate_gas(self, amount: int, tx_params: Optional[TxParams] = None) -> int:
            """Estimate gas consumption of method call."""
            (amount) = self.validate_and_normalize_inputs(amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(amount).estimateGas(tx_params.as_dict())

    class BurnFromMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the burnFrom method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        def validate_and_normalize_inputs(self, account: str, amount: int):
            """Validate the inputs to the burnFrom method."""
            self.validator.assert_valid(
                method_name='burnFrom',
                parameter_name='account',
                argument_value=account,
            )
            account = self.validate_and_checksum_address(account)
            self.validator.assert_valid(
                method_name='burnFrom',
                parameter_name='amount',
                argument_value=amount,
            )
            # safeguard against fractional inputs
            amount = int(amount)
            return (account, amount)

        def block_call(self, account: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> 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: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            self._underlying_method(account, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        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).buildTransaction(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).estimateGas(tx_params.as_dict())

    class CapMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the cap method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

        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 DecimalsMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the decimals method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

        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 DecreaseAllowanceMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the decreaseAllowance method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        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 block_call(self, spender: str, subtracted_value: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :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: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(spender, subtracted_value).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(spender, subtracted_value)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        def send_transaction(self, spender: str, subtracted_value: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :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).buildTransaction(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).estimateGas(tx_params.as_dict())

    class GetDecimalsMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the getDecimals method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

        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 IncreaseAllowanceMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the increaseAllowance method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        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 block_call(self, spender: str, added_value: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :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: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(spender, added_value).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(spender, added_value)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        def send_transaction(self, spender: str, added_value: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :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).buildTransaction(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).estimateGas(tx_params.as_dict())

    class IsMinterMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the isMinter method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        def validate_and_normalize_inputs(self, account: str):
            """Validate the inputs to the isMinter method."""
            self.validator.assert_valid(
                method_name='isMinter',
                parameter_name='account',
                argument_value=account,
            )
            account = self.validate_and_checksum_address(account)
            return (account)

        def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            (account) = self.validate_and_normalize_inputs(account)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(account).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account)

            returned = _fn.call({
                'from': self._operate
            })
            return bool(returned)

        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).estimateGas(tx_params.as_dict())

    class MintMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the mint method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        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 block_call(self, account: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """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: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(account, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        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).buildTransaction(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).estimateGas(tx_params.as_dict())

    class NameMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the name method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return str(returned)

        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 RenounceMinterMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the renounceMinter method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        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 SymbolMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the symbol method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return str(returned)

        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 TokenNameMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the tokenName method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return str(returned)

        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 TokenSymbolMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the tokenSymbol method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return str(returned)

        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 TotalSupplyMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the totalSupply method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
            """Persist instance data."""
            super().__init__(elib, contract_address)
            self._underlying_method = contract_function

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

        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 TransferMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the transfer method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        def validate_and_normalize_inputs(self, recipient: str, amount: int):
            """Validate the inputs to the transfer method."""
            self.validator.assert_valid(
                method_name='transfer',
                parameter_name='recipient',
                argument_value=recipient,
            )
            recipient = self.validate_and_checksum_address(recipient)
            self.validator.assert_valid(
                method_name='transfer',
                parameter_name='amount',
                argument_value=amount,
            )
            # safeguard against fractional inputs
            amount = int(amount)
            return (recipient, amount)

        def block_call(self, recipient: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(recipient, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(recipient, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        def send_transaction(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :param tx_params: transaction parameters
            """
            (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(recipient, amount).transact(tx_params.as_dict())

        def build_transaction(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
            """Construct calldata to be used as input to the method."""
            (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(recipient, amount).buildTransaction(tx_params.as_dict())

        def estimate_gas(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
            """Estimate gas consumption of method call."""
            (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(recipient, amount).estimateGas(tx_params.as_dict())

    class TransferFromMethod(ContractMethod):  # pylint: disable=invalid-name
        """Various interfaces to the transferFrom method."""

        def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
            """Persist instance data."""
            super().__init__(elib, contract_address, validator)
            self._underlying_method = contract_function

        def validate_and_normalize_inputs(self, sender: str, recipient: str, amount: int):
            """Validate the inputs to the transferFrom method."""
            self.validator.assert_valid(
                method_name='transferFrom',
                parameter_name='sender',
                argument_value=sender,
            )
            sender = self.validate_and_checksum_address(sender)
            self.validator.assert_valid(
                method_name='transferFrom',
                parameter_name='recipient',
                argument_value=recipient,
            )
            recipient = self.validate_and_checksum_address(recipient)
            self.validator.assert_valid(
                method_name='transferFrom',
                parameter_name='amount',
                argument_value=amount,
            )
            # safeguard against fractional inputs
            amount = int(amount)
            return (sender, recipient, amount)

        def block_call(self, sender: str, recipient: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(sender, recipient, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(sender, recipient, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

        def send_transaction(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :param tx_params: transaction parameters
            """
            (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(sender, recipient, amount).transact(tx_params.as_dict())

        def build_transaction(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
            """Construct calldata to be used as input to the method."""
            (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(sender, recipient, amount).buildTransaction(tx_params.as_dict())

        def estimate_gas(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
            """Estimate gas consumption of method call."""
            (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(sender, recipient, amount).estimateGas(tx_params.as_dict())

    # pylint: disable=too-many-public-methods,too-many-instance-attributes
    class Ori20:
        """Wrapper class for Ori20 Solidity contract."""
        _fn_add_minter: AddMinterMethod
        """Constructor-initialized instance of
        :class:`AddMinterMethod`.
        """

        _fn_allowance: AllowanceMethod
        """Constructor-initialized instance of
        :class:`AllowanceMethod`.
        """

        _fn_approve: ApproveMethod
        """Constructor-initialized instance of
        :class:`ApproveMethod`.
        """

        _fn_balance_of: BalanceOfMethod
        """Constructor-initialized instance of
        :class:`BalanceOfMethod`.
        """

        _fn_burn: BurnMethod
        """Constructor-initialized instance of
        :class:`BurnMethod`.
        """

        _fn_burn_from: BurnFromMethod
        """Constructor-initialized instance of
        :class:`BurnFromMethod`.
        """

        _fn_cap: CapMethod
        """Constructor-initialized instance of
        :class:`CapMethod`.
        """

        _fn_decimals: DecimalsMethod
        """Constructor-initialized instance of
        :class:`DecimalsMethod`.
        """

        _fn_decrease_allowance: DecreaseAllowanceMethod
        """Constructor-initialized instance of
        :class:`DecreaseAllowanceMethod`.
        """

        _fn_get_decimals: GetDecimalsMethod
        """Constructor-initialized instance of
        :class:`GetDecimalsMethod`.
        """

        _fn_increase_allowance: IncreaseAllowanceMethod
        """Constructor-initialized instance of
        :class:`IncreaseAllowanceMethod`.
        """

        _fn_is_minter: IsMinterMethod
        """Constructor-initialized instance of
        :class:`IsMinterMethod`.
        """

        _fn_mint: MintMethod
        """Constructor-initialized instance of
        :class:`MintMethod`.
        """

        _fn_name: NameMethod
        """Constructor-initialized instance of
        :class:`NameMethod`.
        """

        _fn_renounce_minter: RenounceMinterMethod
        """Constructor-initialized instance of
        :class:`RenounceMinterMethod`.
        """

        _fn_symbol: SymbolMethod
        """Constructor-initialized instance of
        :class:`SymbolMethod`.
        """

        _fn_token_name: TokenNameMethod
        """Constructor-initialized instance of
        :class:`TokenNameMethod`.
        """

        _fn_token_symbol: TokenSymbolMethod
        """Constructor-initialized instance of
        :class:`TokenSymbolMethod`.
        """

        _fn_total_supply: TotalSupplyMethod
        """Constructor-initialized instance of
        :class:`TotalSupplyMethod`.
        """

        _fn_transfer: TransferMethod
        """Constructor-initialized instance of
        :class:`TransferMethod`.
        """

        _fn_transfer_from: TransferFromMethod
        """Constructor-initialized instance of
        :class:`TransferFromMethod`.
        """

        def __init__(
                self,
                core_lib: MiliDoS,
                contract_address: str,
                validator: Ori20Validator = None,
        ):
            """Get an instance of wrapper for smart contract.
            """
            # pylint: disable=too-many-statements

            self.contract_address = contract_address
            web3 = core_lib.w3

            if not validator:
                validator = Ori20Validator(web3, contract_address)

            # if any middleware was imported, inject it
            try:
                MIDDLEWARE
            except NameError:
                pass
            else:
                try:
                    for middleware in MIDDLEWARE:
                        web3.middleware_onion.inject(
                            middleware['function'], layer=middleware['layer'],
                        )
                except ValueError as value_error:
                    if value_error.args == ("You can't add the same un-named instance twice",):
                        pass

            self._web3_eth = web3.eth

            functions = self._web3_eth.contract(address=to_checksum_address(contract_address), abi=Ori20.abi()).functions

            self.call_contract_fee_amount: int = 100000000000000000
            self.call_contract_debug_flag: bool = False
            self.call_contract_enforce_tx_receipt: bool = False

            self._fn_add_minter = AddMinterMethod(core_lib, contract_address, functions.addMinter, validator)

            self._fn_allowance = AllowanceMethod(core_lib, contract_address, functions.allowance, validator)

            self._fn_approve = ApproveMethod(core_lib, contract_address, functions.approve, validator)

            self._fn_balance_of = BalanceOfMethod(core_lib, contract_address, functions.balanceOf, validator)

            self._fn_burn = BurnMethod(core_lib, contract_address, functions.burn, validator)

            self._fn_burn_from = BurnFromMethod(core_lib, contract_address, functions.burnFrom, validator)

            self._fn_cap = CapMethod(core_lib, contract_address, functions.cap)

            self._fn_decimals = DecimalsMethod(core_lib, contract_address, functions.decimals)

            self._fn_decrease_allowance = DecreaseAllowanceMethod(core_lib, contract_address, functions.decreaseAllowance, validator)

            self._fn_get_decimals = GetDecimalsMethod(core_lib, contract_address, functions.getDecimals)

            self._fn_increase_allowance = IncreaseAllowanceMethod(core_lib, contract_address, functions.increaseAllowance, validator)

            self._fn_is_minter = IsMinterMethod(core_lib, contract_address, functions.isMinter, validator)

            self._fn_mint = MintMethod(core_lib, contract_address, functions.mint, validator)

            self._fn_name = NameMethod(core_lib, contract_address, functions.name)

            self._fn_renounce_minter = RenounceMinterMethod(core_lib, contract_address, functions.renounceMinter)

            self._fn_symbol = SymbolMethod(core_lib, contract_address, functions.symbol)

            self._fn_token_name = TokenNameMethod(core_lib, contract_address, functions.tokenName)

            self._fn_token_symbol = TokenSymbolMethod(core_lib, contract_address, functions.tokenSymbol)

            self._fn_total_supply = TotalSupplyMethod(core_lib, contract_address, functions.totalSupply)

            self._fn_transfer = TransferMethod(core_lib, contract_address, functions.transfer, validator)

            self._fn_transfer_from = TransferFromMethod(core_lib, contract_address, functions.transferFrom, validator)

        def event_approval(
                self, tx_hash: Union[HexBytes, bytes]
        ) -> Tuple[AttributeDict]:
            """
            Implementation of event approval in contract Ori20
            Get log entry for Approval event.
                    :param tx_hash: hash of transaction emitting Approval event
            """
            tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
            return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.Approval().processReceipt(tx_receipt)

        def event_minter_added(
                self, tx_hash: Union[HexBytes, bytes]
        ) -> Tuple[AttributeDict]:
            """
            Implementation of event minter_added in contract Ori20
            Get log entry for MinterAdded event.
                    :param tx_hash: hash of transaction emitting MinterAdded event
            """
            tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
            return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.MinterAdded().processReceipt(tx_receipt)

        def event_minter_removed(
                self, tx_hash: Union[HexBytes, bytes]
        ) -> Tuple[AttributeDict]:
            """
            Implementation of event minter_removed in contract Ori20
            Get log entry for MinterRemoved event.
                    :param tx_hash: hash of transaction emitting MinterRemoved event
            """
            tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
            return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.MinterRemoved().processReceipt(tx_receipt)

        def event_transfer(
                self, tx_hash: Union[HexBytes, bytes]
        ) -> Tuple[AttributeDict]:
            """
            Implementation of event transfer in contract Ori20
            Get log entry for Transfer event.
                    :param tx_hash: hash of transaction emitting Transfer event
            """
            tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
            return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.Transfer().processReceipt(tx_receipt)

        def add_minter(self, account: str) -> None:
            """
            Implementation of add_minter in contract Ori20

            """
            return self._fn_add_minter.block_call(account, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def allowance(self, owner: str, spender: str) -> int:
            """
            Implementation of allowance in contract Ori20

            """
            return self._fn_allowance.block_call(owner, spender)

        def approve(self, spender: str, amount: int) -> bool:
            """
            Implementation of approve in contract Ori20

            """
            return self._fn_approve.block_call(spender, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def balance_of(self, account: str) -> int:
            """
            Implementation of balance_of in contract Ori20

            """
            return self._fn_balance_of.block_call(account)

        def burn(self, amount: int) -> None:
            """
            Implementation of burn in contract Ori20

            """
            return self._fn_burn.block_call(amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def burn_from(self, account: str, amount: int) -> None:
            """
            Implementation of burn_from in contract Ori20

            """
            return self._fn_burn_from.block_call(account, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def cap(self) -> int:
            """
            Implementation of cap in contract Ori20

            """
            return self._fn_cap.block_call()

        def decimals(self) -> int:
            """
            Implementation of decimals in contract Ori20

            """
            return self._fn_decimals.block_call()

        def decrease_allowance(self, spender: str, subtracted_value: int) -> bool:
            """
            Implementation of decrease_allowance in contract Ori20

            """
            return self._fn_decrease_allowance.block_call(spender, subtracted_value, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def get_decimals(self) -> int:
            """
            Implementation of get_decimals in contract Ori20

            """
            return self._fn_get_decimals.block_call()

        def increase_allowance(self, spender: str, added_value: int) -> bool:
            """
            Implementation of increase_allowance in contract Ori20

            """
            return self._fn_increase_allowance.block_call(spender, added_value, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def is_minter(self, account: str) -> bool:
            """
            Implementation of is_minter in contract Ori20

            """
            return self._fn_is_minter.block_call(account)

        def mint(self, account: str, amount: int) -> bool:
            """
            Implementation of mint in contract Ori20

            """
            return self._fn_mint.block_call(account, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def name(self) -> str:
            """
            Implementation of name in contract Ori20

            """
            return self._fn_name.block_call()

        def renounce_minter(self) -> None:
            """
            Implementation of renounce_minter in contract Ori20

            """
            return self._fn_renounce_minter.block_call(0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def symbol(self) -> str:
            """
            Implementation of symbol in contract Ori20

            """
            return self._fn_symbol.block_call()

        def token_name(self) -> str:
            """
            Implementation of token_name in contract Ori20

            """
            return self._fn_token_name.block_call()

        def token_symbol(self) -> str:
            """
            Implementation of token_symbol in contract Ori20

            """
            return self._fn_token_symbol.block_call()

        def total_supply(self) -> int:
            """
            Implementation of total_supply in contract Ori20

            """
            return self._fn_total_supply.block_call()

        def transfer(self, recipient: str, amount: int) -> bool:
            """
            Implementation of transfer in contract Ori20

            """
            return self._fn_transfer.block_call(recipient, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def transfer_from(self, sender: str, recipient: str, amount: int) -> bool:
            """
            Implementation of transfer_from in contract Ori20

            """
            return self._fn_transfer_from.block_call(sender, recipient, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

        def CallContractFee(self, amount: int) -> "Ori20":
            self.call_contract_fee_amount = amount
            return self

        def CallDebug(self, yesno: bool) -> "Ori20":
            self.call_contract_debug_flag = yesno
            return self

        def EnforceTxReceipt(self, yesno: bool) -> "Ori20":
            self.call_contract_enforce_tx_receipt = yesno
            return self

        @staticmethod
        def abi():
            """Return the ABI to the underlying contract."""
            return json.loads(
                '[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"MinterAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"MinterRemoved","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"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addMinter","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getDecimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceMinter","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenName","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenSymbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]'
                # noqa: E501 (line-too-long)
            )

    # pylint: disable=too-many-lines

## Classes

`class AddMinterMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the addMinter method.

  Persist instance data.

  Expand source code

      class AddMinterMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the addMinter method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          def validate_and_normalize_inputs(self, account: str):
              """Validate the inputs to the addMinter method."""
              self.validator.assert_valid(
                  method_name='addMinter',
                  parameter_name='account',
                  argument_value=account,
              )
              account = self.validate_and_checksum_address(account)
              return (account)

          def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters
              :returns: the return value of the underlying method.

              (account) = self.validate_and_normalize_inputs(account)

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              self._underlying_method(account).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(account)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          def send_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
              """Execute underlying contract method via eth_sendTransaction.

              :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).buildTransaction(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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> NoneType`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters :returns: the return value of the underlying method.

    (account) = self.validate_and_normalize_inputs(account)

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    self._underlying_method(account).call(tx_params.as_dict())

    Expand source code

        def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (account) = self.validate_and_normalize_inputs(account)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            self._underlying_method(account).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        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).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def send_transaction(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        def send_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :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 validate_and_normalize_inputs(self, account: str)`

    Validate the inputs to the addMinter method.

    Expand source code

        def validate_and_normalize_inputs(self, account: str):
            """Validate the inputs to the addMinter method."""
            self.validator.assert_valid(
                method_name='addMinter',
                parameter_name='account',
                argument_value=account,
            )
            account = self.validate_and_checksum_address(account)
            return (account)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class AllowanceMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the allowance method.

  Persist instance data.

  Expand source code

      class AllowanceMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the allowance method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          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 block_call(self, owner: str, spender: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              (owner, spender) = self.validate_and_normalize_inputs(owner, spender)

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(owner, spender).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(owner, spender)

              returned = _fn.call({
                  'from': self._operate
              })
              return int(returned)

          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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, owner: str, spender: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> int`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    (owner, spender) = self.validate_and_normalize_inputs(owner, spender)

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(owner, spender).call(tx_params.as_dict())

    Expand source code

        def block_call(self, owner: str, spender: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            (owner, spender) = self.validate_and_normalize_inputs(owner, spender)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(owner, spender).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(owner, spender)

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

  `def estimate_gas(self, owner: str, spender: str, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def validate_and_normalize_inputs(self, owner: str, spender: str)`

    Validate the inputs to the allowance method.

    Expand source code

        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)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class ApproveMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the approve method.

  Persist instance data.

  Expand source code

      class ApproveMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the approve method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          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 block_call(self, spender: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters
              :returns: the return value of the underlying method.

              (spender, amount) = self.validate_and_normalize_inputs(spender, amount)

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(spender, amount).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(spender, amount)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          def send_transaction(self, spender: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
              """Execute underlying contract method via eth_sendTransaction.

              :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).buildTransaction(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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, spender: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> bool`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters :returns: the return value of the underlying method.

    (spender, amount) = self.validate_and_normalize_inputs(spender, amount)

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(spender, amount).call(tx_params.as_dict())

    Expand source code

        def block_call(self, spender: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (spender, amount) = self.validate_and_normalize_inputs(spender, amount)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(spender, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(spender, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, spender: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        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).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, spender: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def send_transaction(self, spender: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        def send_transaction(self, spender: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :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 validate_and_normalize_inputs(self, spender: str, amount: int)`

    Validate the inputs to the approve method.

    Expand source code

        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)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class BalanceOfMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the balanceOf method.

  Persist instance data.

  Expand source code

      class BalanceOfMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the balanceOf method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          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 block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              (account) = self.validate_and_normalize_inputs(account)

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(account).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(account)

              returned = _fn.call({
                  'from': self._operate
              })
              return int(returned)

          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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> int`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    (account) = self.validate_and_normalize_inputs(account)

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(account).call(tx_params.as_dict())

    Expand source code

        def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            (account) = self.validate_and_normalize_inputs(account)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(account).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account)

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

  `def estimate_gas(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def validate_and_normalize_inputs(self, account: str)`

    Validate the inputs to the balanceOf method.

    Expand source code

        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)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class BurnFromMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the burnFrom method.

  Persist instance data.

  Expand source code

      class BurnFromMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the burnFrom method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          def validate_and_normalize_inputs(self, account: str, amount: int):
              """Validate the inputs to the burnFrom method."""
              self.validator.assert_valid(
                  method_name='burnFrom',
                  parameter_name='account',
                  argument_value=account,
              )
              account = self.validate_and_checksum_address(account)
              self.validator.assert_valid(
                  method_name='burnFrom',
                  parameter_name='amount',
                  argument_value=amount,
              )
              # safeguard against fractional inputs
              amount = int(amount)
              return (account, amount)

          def block_call(self, account: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> 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: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              self._underlying_method(account, amount).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(account, amount)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          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).buildTransaction(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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, account: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> NoneType`

    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: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    self._underlying_method(account, amount).call(tx_params.as_dict())

    Expand source code

        def block_call(self, account: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> 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: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            self._underlying_method(account, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, account: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        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).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, account: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def send_transaction(self, account: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        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 validate_and_normalize_inputs(self, account: str, amount: int)`

    Validate the inputs to the burnFrom method.

    Expand source code

        def validate_and_normalize_inputs(self, account: str, amount: int):
            """Validate the inputs to the burnFrom method."""
            self.validator.assert_valid(
                method_name='burnFrom',
                parameter_name='account',
                argument_value=account,
            )
            account = self.validate_and_checksum_address(account)
            self.validator.assert_valid(
                method_name='burnFrom',
                parameter_name='amount',
                argument_value=amount,
            )
            # safeguard against fractional inputs
            amount = int(amount)
            return (account, amount)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class BurnMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the burn method.

  Persist instance data.

  Expand source code

      class BurnMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the burn method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          def validate_and_normalize_inputs(self, amount: int):
              """Validate the inputs to the burn method."""
              self.validator.assert_valid(
                  method_name='burn',
                  parameter_name='amount',
                  argument_value=amount,
              )
              # safeguard against fractional inputs
              amount = int(amount)
              return (amount)

          def block_call(self, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters
              :returns: the return value of the underlying method.

              (amount) = self.validate_and_normalize_inputs(amount)

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              self._underlying_method(amount).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(amount)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          def send_transaction(self, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
              """Execute underlying contract method via eth_sendTransaction.

              :param tx_params: transaction parameters
              """
              (amount) = self.validate_and_normalize_inputs(amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(amount).transact(tx_params.as_dict())

          def build_transaction(self, amount: int, tx_params: Optional[TxParams] = None) -> dict:
              """Construct calldata to be used as input to the method."""
              (amount) = self.validate_and_normalize_inputs(amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(amount).buildTransaction(tx_params.as_dict())

          def estimate_gas(self, amount: int, tx_params: Optional[TxParams] = None) -> int:
              """Estimate gas consumption of method call."""
              (amount) = self.validate_and_normalize_inputs(amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(amount).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> NoneType`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters :returns: the return value of the underlying method.

    (amount) = self.validate_and_normalize_inputs(amount)

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    self._underlying_method(amount).call(tx_params.as_dict())

    Expand source code

        def block_call(self, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (amount) = self.validate_and_normalize_inputs(amount)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            self._underlying_method(amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        def build_transaction(self, amount: int, tx_params: Optional[TxParams] = None) -> dict:
            """Construct calldata to be used as input to the method."""
            (amount) = self.validate_and_normalize_inputs(amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(amount).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        def estimate_gas(self, amount: int, tx_params: Optional[TxParams] = None) -> int:
            """Estimate gas consumption of method call."""
            (amount) = self.validate_and_normalize_inputs(amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(amount).estimateGas(tx_params.as_dict())

  `def send_transaction(self, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        def send_transaction(self, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :param tx_params: transaction parameters
            """
            (amount) = self.validate_and_normalize_inputs(amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(amount).transact(tx_params.as_dict())

  `def validate_and_normalize_inputs(self, amount: int)`

    Validate the inputs to the burn method.

    Expand source code

        def validate_and_normalize_inputs(self, amount: int):
            """Validate the inputs to the burn method."""
            self.validator.assert_valid(
                method_name='burn',
                parameter_name='amount',
                argument_value=amount,
            )
            # safeguard against fractional inputs
            amount = int(amount)
            return (amount)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class CapMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the cap method.

  Persist instance data.

  Expand source code

      class CapMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the cap method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              returned = _fn.call({
                  'from': self._operate
              })
              return int(returned)

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> int`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

  `def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class DecimalsMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the decimals method.

  Persist instance data.

  Expand source code

      class DecimalsMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the decimals method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              returned = _fn.call({
                  'from': self._operate
              })
              return int(returned)

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> int`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

  `def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class DecreaseAllowanceMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the decreaseAllowance method.

  Persist instance data.

  Expand source code

      class DecreaseAllowanceMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the decreaseAllowance method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          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 block_call(self, spender: str, subtracted_value: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
              """Execute underlying contract method via eth_call.

              :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: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(spender, subtracted_value).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(spender, subtracted_value)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          def send_transaction(self, spender: str, subtracted_value: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
              """Execute underlying contract method via eth_sendTransaction.

              :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).buildTransaction(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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, spender: str, subtracted_value: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> bool`

    Execute underlying contract method via eth_call.

    :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: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(spender, subtracted_value).call(tx_params.as_dict())

    Expand source code

        def block_call(self, spender: str, subtracted_value: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :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: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(spender, subtracted_value).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(spender, subtracted_value)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, spender: str, subtracted_value: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        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).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, spender: str, subtracted_value: int, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def send_transaction(self, spender: str, subtracted_value: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        def send_transaction(self, spender: str, subtracted_value: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :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 validate_and_normalize_inputs(self, spender: str, subtracted_value: int)`

    Validate the inputs to the decreaseAllowance method.

    Expand source code

        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)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class GetDecimalsMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the getDecimals method.

  Persist instance data.

  Expand source code

      class GetDecimalsMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the getDecimals method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              returned = _fn.call({
                  'from': self._operate
              })
              return int(returned)

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> int`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

  `def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class IncreaseAllowanceMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the increaseAllowance method.

  Persist instance data.

  Expand source code

      class IncreaseAllowanceMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the increaseAllowance method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          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 block_call(self, spender: str, added_value: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
              """Execute underlying contract method via eth_call.

              :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: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(spender, added_value).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(spender, added_value)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          def send_transaction(self, spender: str, added_value: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
              """Execute underlying contract method via eth_sendTransaction.

              :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).buildTransaction(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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, spender: str, added_value: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> bool`

    Execute underlying contract method via eth_call.

    :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: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(spender, added_value).call(tx_params.as_dict())

    Expand source code

        def block_call(self, spender: str, added_value: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :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: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(spender, added_value).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(spender, added_value)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, spender: str, added_value: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        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).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, spender: str, added_value: int, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def send_transaction(self, spender: str, added_value: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        def send_transaction(self, spender: str, added_value: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :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 validate_and_normalize_inputs(self, spender: str, added_value: int)`

    Validate the inputs to the increaseAllowance method.

    Expand source code

        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)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class IsMinterMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the isMinter method.

  Persist instance data.

  Expand source code

      class IsMinterMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the isMinter method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          def validate_and_normalize_inputs(self, account: str):
              """Validate the inputs to the isMinter method."""
              self.validator.assert_valid(
                  method_name='isMinter',
                  parameter_name='account',
                  argument_value=account,
              )
              account = self.validate_and_checksum_address(account)
              return (account)

          def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              (account) = self.validate_and_normalize_inputs(account)

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(account).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(account)

              returned = _fn.call({
                  'from': self._operate
              })
              return bool(returned)

          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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> bool`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    (account) = self.validate_and_normalize_inputs(account)

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(account).call(tx_params.as_dict())

    Expand source code

        def block_call(self, account: str, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            (account) = self.validate_and_normalize_inputs(account)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(account).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account)

            returned = _fn.call({
                'from': self._operate
            })
            return bool(returned)

  `def estimate_gas(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def validate_and_normalize_inputs(self, account: str)`

    Validate the inputs to the isMinter method.

    Expand source code

        def validate_and_normalize_inputs(self, account: str):
            """Validate the inputs to the isMinter method."""
            self.validator.assert_valid(
                method_name='isMinter',
                parameter_name='account',
                argument_value=account,
            )
            account = self.validate_and_checksum_address(account)
            return (account)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class MintMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the mint method.

  Persist instance data.

  Expand source code

      class MintMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the mint method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          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 block_call(self, account: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
              """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: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(account, amount).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(account, amount)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          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).buildTransaction(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).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, account: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> bool`

    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: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(account, amount).call(tx_params.as_dict())

    Expand source code

        def block_call(self, account: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """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: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(account, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(account, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, account: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        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).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, account: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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).estimateGas(tx_params.as_dict())

  `def send_transaction(self, account: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        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 validate_and_normalize_inputs(self, account: str, amount: int)`

    Validate the inputs to the mint method.

    Expand source code

        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)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class NameMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the name method.

  Persist instance data.

  Expand source code

      class NameMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the name method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              returned = _fn.call({
                  'from': self._operate
              })
              return str(returned)

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> str`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return str(returned)

  `def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class Ori20 (core_lib: MiliDoS, contract_address: str, validator: Ori20Validator = None)`

  Wrapper class for Ori20 Solidity contract.

  Get an instance of wrapper for smart contract.

  Expand source code

      class Ori20:
          """Wrapper class for Ori20 Solidity contract."""
          _fn_add_minter: AddMinterMethod
          """Constructor-initialized instance of
          :class:`AddMinterMethod`.
          """

          _fn_allowance: AllowanceMethod
          """Constructor-initialized instance of
          :class:`AllowanceMethod`.
          """

          _fn_approve: ApproveMethod
          """Constructor-initialized instance of
          :class:`ApproveMethod`.
          """

          _fn_balance_of: BalanceOfMethod
          """Constructor-initialized instance of
          :class:`BalanceOfMethod`.
          """

          _fn_burn: BurnMethod
          """Constructor-initialized instance of
          :class:`BurnMethod`.
          """

          _fn_burn_from: BurnFromMethod
          """Constructor-initialized instance of
          :class:`BurnFromMethod`.
          """

          _fn_cap: CapMethod
          """Constructor-initialized instance of
          :class:`CapMethod`.
          """

          _fn_decimals: DecimalsMethod
          """Constructor-initialized instance of
          :class:`DecimalsMethod`.
          """

          _fn_decrease_allowance: DecreaseAllowanceMethod
          """Constructor-initialized instance of
          :class:`DecreaseAllowanceMethod`.
          """

          _fn_get_decimals: GetDecimalsMethod
          """Constructor-initialized instance of
          :class:`GetDecimalsMethod`.
          """

          _fn_increase_allowance: IncreaseAllowanceMethod
          """Constructor-initialized instance of
          :class:`IncreaseAllowanceMethod`.
          """

          _fn_is_minter: IsMinterMethod
          """Constructor-initialized instance of
          :class:`IsMinterMethod`.
          """

          _fn_mint: MintMethod
          """Constructor-initialized instance of
          :class:`MintMethod`.
          """

          _fn_name: NameMethod
          """Constructor-initialized instance of
          :class:`NameMethod`.
          """

          _fn_renounce_minter: RenounceMinterMethod
          """Constructor-initialized instance of
          :class:`RenounceMinterMethod`.
          """

          _fn_symbol: SymbolMethod
          """Constructor-initialized instance of
          :class:`SymbolMethod`.
          """

          _fn_token_name: TokenNameMethod
          """Constructor-initialized instance of
          :class:`TokenNameMethod`.
          """

          _fn_token_symbol: TokenSymbolMethod
          """Constructor-initialized instance of
          :class:`TokenSymbolMethod`.
          """

          _fn_total_supply: TotalSupplyMethod
          """Constructor-initialized instance of
          :class:`TotalSupplyMethod`.
          """

          _fn_transfer: TransferMethod
          """Constructor-initialized instance of
          :class:`TransferMethod`.
          """

          _fn_transfer_from: TransferFromMethod
          """Constructor-initialized instance of
          :class:`TransferFromMethod`.
          """

          def __init__(
                  self,
                  core_lib: MiliDoS,
                  contract_address: str,
                  validator: Ori20Validator = None,
          ):
              """Get an instance of wrapper for smart contract.
              """
              # pylint: disable=too-many-statements

              self.contract_address = contract_address
              web3 = core_lib.w3

              if not validator:
                  validator = Ori20Validator(web3, contract_address)

              # if any middleware was imported, inject it
              try:
                  MIDDLEWARE
              except NameError:
                  pass
              else:
                  try:
                      for middleware in MIDDLEWARE:
                          web3.middleware_onion.inject(
                              middleware['function'], layer=middleware['layer'],
                          )
                  except ValueError as value_error:
                      if value_error.args == ("You can't add the same un-named instance twice",):
                          pass

              self._web3_eth = web3.eth

              functions = self._web3_eth.contract(address=to_checksum_address(contract_address), abi=Ori20.abi()).functions

              self.call_contract_fee_amount: int = 100000000000000000
              self.call_contract_debug_flag: bool = False
              self.call_contract_enforce_tx_receipt: bool = False

              self._fn_add_minter = AddMinterMethod(core_lib, contract_address, functions.addMinter, validator)

              self._fn_allowance = AllowanceMethod(core_lib, contract_address, functions.allowance, validator)

              self._fn_approve = ApproveMethod(core_lib, contract_address, functions.approve, validator)

              self._fn_balance_of = BalanceOfMethod(core_lib, contract_address, functions.balanceOf, validator)

              self._fn_burn = BurnMethod(core_lib, contract_address, functions.burn, validator)

              self._fn_burn_from = BurnFromMethod(core_lib, contract_address, functions.burnFrom, validator)

              self._fn_cap = CapMethod(core_lib, contract_address, functions.cap)

              self._fn_decimals = DecimalsMethod(core_lib, contract_address, functions.decimals)

              self._fn_decrease_allowance = DecreaseAllowanceMethod(core_lib, contract_address, functions.decreaseAllowance, validator)

              self._fn_get_decimals = GetDecimalsMethod(core_lib, contract_address, functions.getDecimals)

              self._fn_increase_allowance = IncreaseAllowanceMethod(core_lib, contract_address, functions.increaseAllowance, validator)

              self._fn_is_minter = IsMinterMethod(core_lib, contract_address, functions.isMinter, validator)

              self._fn_mint = MintMethod(core_lib, contract_address, functions.mint, validator)

              self._fn_name = NameMethod(core_lib, contract_address, functions.name)

              self._fn_renounce_minter = RenounceMinterMethod(core_lib, contract_address, functions.renounceMinter)

              self._fn_symbol = SymbolMethod(core_lib, contract_address, functions.symbol)

              self._fn_token_name = TokenNameMethod(core_lib, contract_address, functions.tokenName)

              self._fn_token_symbol = TokenSymbolMethod(core_lib, contract_address, functions.tokenSymbol)

              self._fn_total_supply = TotalSupplyMethod(core_lib, contract_address, functions.totalSupply)

              self._fn_transfer = TransferMethod(core_lib, contract_address, functions.transfer, validator)

              self._fn_transfer_from = TransferFromMethod(core_lib, contract_address, functions.transferFrom, validator)

          def event_approval(
                  self, tx_hash: Union[HexBytes, bytes]
          ) -> Tuple[AttributeDict]:
              """
              Implementation of event approval in contract Ori20
              Get log entry for Approval event.
                      :param tx_hash: hash of transaction emitting Approval event
              """
              tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
              return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.Approval().processReceipt(tx_receipt)

          def event_minter_added(
                  self, tx_hash: Union[HexBytes, bytes]
          ) -> Tuple[AttributeDict]:
              """
              Implementation of event minter_added in contract Ori20
              Get log entry for MinterAdded event.
                      :param tx_hash: hash of transaction emitting MinterAdded event
              """
              tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
              return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.MinterAdded().processReceipt(tx_receipt)

          def event_minter_removed(
                  self, tx_hash: Union[HexBytes, bytes]
          ) -> Tuple[AttributeDict]:
              """
              Implementation of event minter_removed in contract Ori20
              Get log entry for MinterRemoved event.
                      :param tx_hash: hash of transaction emitting MinterRemoved event
              """
              tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
              return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.MinterRemoved().processReceipt(tx_receipt)

          def event_transfer(
                  self, tx_hash: Union[HexBytes, bytes]
          ) -> Tuple[AttributeDict]:
              """
              Implementation of event transfer in contract Ori20
              Get log entry for Transfer event.
                      :param tx_hash: hash of transaction emitting Transfer event
              """
              tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
              return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.Transfer().processReceipt(tx_receipt)

          def add_minter(self, account: str) -> None:
              """
              Implementation of add_minter in contract Ori20

              """
              return self._fn_add_minter.block_call(account, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def allowance(self, owner: str, spender: str) -> int:
              """
              Implementation of allowance in contract Ori20

              """
              return self._fn_allowance.block_call(owner, spender)

          def approve(self, spender: str, amount: int) -> bool:
              """
              Implementation of approve in contract Ori20

              """
              return self._fn_approve.block_call(spender, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def balance_of(self, account: str) -> int:
              """
              Implementation of balance_of in contract Ori20

              """
              return self._fn_balance_of.block_call(account)

          def burn(self, amount: int) -> None:
              """
              Implementation of burn in contract Ori20

              """
              return self._fn_burn.block_call(amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def burn_from(self, account: str, amount: int) -> None:
              """
              Implementation of burn_from in contract Ori20

              """
              return self._fn_burn_from.block_call(account, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def cap(self) -> int:
              """
              Implementation of cap in contract Ori20

              """
              return self._fn_cap.block_call()

          def decimals(self) -> int:
              """
              Implementation of decimals in contract Ori20

              """
              return self._fn_decimals.block_call()

          def decrease_allowance(self, spender: str, subtracted_value: int) -> bool:
              """
              Implementation of decrease_allowance in contract Ori20

              """
              return self._fn_decrease_allowance.block_call(spender, subtracted_value, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def get_decimals(self) -> int:
              """
              Implementation of get_decimals in contract Ori20

              """
              return self._fn_get_decimals.block_call()

          def increase_allowance(self, spender: str, added_value: int) -> bool:
              """
              Implementation of increase_allowance in contract Ori20

              """
              return self._fn_increase_allowance.block_call(spender, added_value, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def is_minter(self, account: str) -> bool:
              """
              Implementation of is_minter in contract Ori20

              """
              return self._fn_is_minter.block_call(account)

          def mint(self, account: str, amount: int) -> bool:
              """
              Implementation of mint in contract Ori20

              """
              return self._fn_mint.block_call(account, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def name(self) -> str:
              """
              Implementation of name in contract Ori20

              """
              return self._fn_name.block_call()

          def renounce_minter(self) -> None:
              """
              Implementation of renounce_minter in contract Ori20

              """
              return self._fn_renounce_minter.block_call(0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def symbol(self) -> str:
              """
              Implementation of symbol in contract Ori20

              """
              return self._fn_symbol.block_call()

          def token_name(self) -> str:
              """
              Implementation of token_name in contract Ori20

              """
              return self._fn_token_name.block_call()

          def token_symbol(self) -> str:
              """
              Implementation of token_symbol in contract Ori20

              """
              return self._fn_token_symbol.block_call()

          def total_supply(self) -> int:
              """
              Implementation of total_supply in contract Ori20

              """
              return self._fn_total_supply.block_call()

          def transfer(self, recipient: str, amount: int) -> bool:
              """
              Implementation of transfer in contract Ori20

              """
              return self._fn_transfer.block_call(recipient, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def transfer_from(self, sender: str, recipient: str, amount: int) -> bool:
              """
              Implementation of transfer_from in contract Ori20

              """
              return self._fn_transfer_from.block_call(sender, recipient, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

          def CallContractFee(self, amount: int) -> "Ori20":
              self.call_contract_fee_amount = amount
              return self

          def CallDebug(self, yesno: bool) -> "Ori20":
              self.call_contract_debug_flag = yesno
              return self

          def EnforceTxReceipt(self, yesno: bool) -> "Ori20":
              self.call_contract_enforce_tx_receipt = yesno
              return self

          @staticmethod
          def abi():
              """Return the ABI to the underlying contract."""
              return json.loads(
                  '[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"MinterAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"MinterRemoved","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"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addMinter","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getDecimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceMinter","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenName","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenSymbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]'
                  # noqa: E501 (line-too-long)
              )

  ### Static methods

  `def abi()`

    Return the ABI to the underlying contract.

    Expand source code

        @staticmethod
        def abi():
            """Return the ABI to the underlying contract."""
            return json.loads(
                '[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"MinterAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"MinterRemoved","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"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addMinter","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getDecimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceMinter","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenName","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenSymbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]'
                # noqa: E501 (line-too-long)
            )

  ### Methods

  `def CallContractFee(self, amount: int) ‑> Ori20`
    Expand source code

        def CallContractFee(self, amount: int) -> "Ori20":
            self.call_contract_fee_amount = amount
            return self

  `def CallDebug(self, yesno: bool) ‑> Ori20`
    Expand source code

        def CallDebug(self, yesno: bool) -> "Ori20":
            self.call_contract_debug_flag = yesno
            return self

  `def EnforceTxReceipt(self, yesno: bool) ‑> Ori20`
    Expand source code

        def EnforceTxReceipt(self, yesno: bool) -> "Ori20":
            self.call_contract_enforce_tx_receipt = yesno
            return self

  `def add_minter(self, account: str) ‑> NoneType`

    Implementation of add_minter in contract Ori20

    Expand source code

        def add_minter(self, account: str) -> None:
            """
            Implementation of add_minter in contract Ori20

            """
            return self._fn_add_minter.block_call(account, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def allowance(self, owner: str, spender: str) ‑> int`

    Implementation of allowance in contract Ori20

    Expand source code

        def allowance(self, owner: str, spender: str) -> int:
            """
            Implementation of allowance in contract Ori20

            """
            return self._fn_allowance.block_call(owner, spender)

  `def approve(self, spender: str, amount: int) ‑> bool`

    Implementation of approve in contract Ori20

    Expand source code

        def approve(self, spender: str, amount: int) -> bool:
            """
            Implementation of approve in contract Ori20

            """
            return self._fn_approve.block_call(spender, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def balance_of(self, account: str) ‑> int`

    Implementation of balance_of in contract Ori20

    Expand source code

        def balance_of(self, account: str) -> int:
            """
            Implementation of balance_of in contract Ori20

            """
            return self._fn_balance_of.block_call(account)

  `def burn(self, amount: int) ‑> NoneType`

    Implementation of burn in contract Ori20

    Expand source code

        def burn(self, amount: int) -> None:
            """
            Implementation of burn in contract Ori20

            """
            return self._fn_burn.block_call(amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def burn_from(self, account: str, amount: int) ‑> NoneType`

    Implementation of burn_from in contract Ori20

    Expand source code

        def burn_from(self, account: str, amount: int) -> None:
            """
            Implementation of burn_from in contract Ori20

            """
            return self._fn_burn_from.block_call(account, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def cap(self) ‑> int`

    Implementation of cap in contract Ori20

    Expand source code

        def cap(self) -> int:
            """
            Implementation of cap in contract Ori20

            """
            return self._fn_cap.block_call()

  `def decimals(self) ‑> int`

    Implementation of decimals in contract Ori20

    Expand source code

        def decimals(self) -> int:
            """
            Implementation of decimals in contract Ori20

            """
            return self._fn_decimals.block_call()

  `def decrease_allowance(self, spender: str, subtracted_value: int) ‑> bool`

    Implementation of decrease_allowance in contract Ori20

    Expand source code

        def decrease_allowance(self, spender: str, subtracted_value: int) -> bool:
            """
            Implementation of decrease_allowance in contract Ori20

            """
            return self._fn_decrease_allowance.block_call(spender, subtracted_value, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def event_approval(self, tx_hash: Union[hexbytes.main.HexBytes, bytes]) ‑> Tuple[web3.datastructures.AttributeDict]`

    Implementation of event approval in contract Ori20 Get log entry for Approval event. :param tx_hash: hash of transaction emitting Approval event

    Expand source code

        def event_approval(
                self, tx_hash: Union[HexBytes, bytes]
        ) -> Tuple[AttributeDict]:
            """
            Implementation of event approval in contract Ori20
            Get log entry for Approval event.
                    :param tx_hash: hash of transaction emitting Approval event
            """
            tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
            return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.Approval().processReceipt(tx_receipt)

  `def event_minter_added(self, tx_hash: Union[hexbytes.main.HexBytes, bytes]) ‑> Tuple[web3.datastructures.AttributeDict]`

    Implementation of event minter_added in contract Ori20 Get log entry for MinterAdded event. :param tx_hash: hash of transaction emitting MinterAdded event

    Expand source code

        def event_minter_added(
                self, tx_hash: Union[HexBytes, bytes]
        ) -> Tuple[AttributeDict]:
            """
            Implementation of event minter_added in contract Ori20
            Get log entry for MinterAdded event.
                    :param tx_hash: hash of transaction emitting MinterAdded event
            """
            tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
            return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.MinterAdded().processReceipt(tx_receipt)

  `def event_minter_removed(self, tx_hash: Union[hexbytes.main.HexBytes, bytes]) ‑> Tuple[web3.datastructures.AttributeDict]`

    Implementation of event minter_removed in contract Ori20 Get log entry for MinterRemoved event. :param tx_hash: hash of transaction emitting MinterRemoved event

    Expand source code

        def event_minter_removed(
                self, tx_hash: Union[HexBytes, bytes]
        ) -> Tuple[AttributeDict]:
            """
            Implementation of event minter_removed in contract Ori20
            Get log entry for MinterRemoved event.
                    :param tx_hash: hash of transaction emitting MinterRemoved event
            """
            tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
            return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.MinterRemoved().processReceipt(tx_receipt)

  `def event_transfer(self, tx_hash: Union[hexbytes.main.HexBytes, bytes]) ‑> Tuple[web3.datastructures.AttributeDict]`

    Implementation of event transfer in contract Ori20 Get log entry for Transfer event. :param tx_hash: hash of transaction emitting Transfer event

    Expand source code

        def event_transfer(
                self, tx_hash: Union[HexBytes, bytes]
        ) -> Tuple[AttributeDict]:
            """
            Implementation of event transfer in contract Ori20
            Get log entry for Transfer event.
                    :param tx_hash: hash of transaction emitting Transfer event
            """
            tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
            return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=Ori20.abi()).events.Transfer().processReceipt(tx_receipt)

  `def get_decimals(self) ‑> int`

    Implementation of get_decimals in contract Ori20

    Expand source code

        def get_decimals(self) -> int:
            """
            Implementation of get_decimals in contract Ori20

            """
            return self._fn_get_decimals.block_call()

  `def increase_allowance(self, spender: str, added_value: int) ‑> bool`

    Implementation of increase_allowance in contract Ori20

    Expand source code

        def increase_allowance(self, spender: str, added_value: int) -> bool:
            """
            Implementation of increase_allowance in contract Ori20

            """
            return self._fn_increase_allowance.block_call(spender, added_value, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def is_minter(self, account: str) ‑> bool`

    Implementation of is_minter in contract Ori20

    Expand source code

        def is_minter(self, account: str) -> bool:
            """
            Implementation of is_minter in contract Ori20

            """
            return self._fn_is_minter.block_call(account)

  `def mint(self, account: str, amount: int) ‑> bool`

    Implementation of mint in contract Ori20

    Expand source code

        def mint(self, account: str, amount: int) -> bool:
            """
            Implementation of mint in contract Ori20

            """
            return self._fn_mint.block_call(account, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def name(self) ‑> str`

    Implementation of name in contract Ori20

    Expand source code

        def name(self) -> str:
            """
            Implementation of name in contract Ori20

            """
            return self._fn_name.block_call()

  `def renounce_minter(self) ‑> NoneType`

    Implementation of renounce_minter in contract Ori20

    Expand source code

        def renounce_minter(self) -> None:
            """
            Implementation of renounce_minter in contract Ori20

            """
            return self._fn_renounce_minter.block_call(0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def symbol(self) ‑> str`

    Implementation of symbol in contract Ori20

    Expand source code

        def symbol(self) -> str:
            """
            Implementation of symbol in contract Ori20

            """
            return self._fn_symbol.block_call()

  `def token_name(self) ‑> str`

    Implementation of token_name in contract Ori20

    Expand source code

        def token_name(self) -> str:
            """
            Implementation of token_name in contract Ori20

            """
            return self._fn_token_name.block_call()

  `def token_symbol(self) ‑> str`

    Implementation of token_symbol in contract Ori20

    Expand source code

        def token_symbol(self) -> str:
            """
            Implementation of token_symbol in contract Ori20

            """
            return self._fn_token_symbol.block_call()

  `def total_supply(self) ‑> int`

    Implementation of total_supply in contract Ori20

    Expand source code

        def total_supply(self) -> int:
            """
            Implementation of total_supply in contract Ori20

            """
            return self._fn_total_supply.block_call()

  `def transfer(self, recipient: str, amount: int) ‑> bool`

    Implementation of transfer in contract Ori20

    Expand source code

        def transfer(self, recipient: str, amount: int) -> bool:
            """
            Implementation of transfer in contract Ori20

            """
            return self._fn_transfer.block_call(recipient, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

  `def transfer_from(self, sender: str, recipient: str, amount: int) ‑> bool`

    Implementation of transfer_from in contract Ori20

    Expand source code

        def transfer_from(self, sender: str, recipient: str, amount: int) -> bool:
            """
            Implementation of transfer_from in contract Ori20

            """
            return self._fn_transfer_from.block_call(sender, recipient, amount, 0, self.call_contract_fee_amount, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)

`class Ori20Validator (web3_or_provider: web3.main.Web3, contract_address: str)`

  No-op input validator.

  Initialize the instance.

  Expand source code

      class Ori20Validator(  # type: ignore
          Validator
      ):
          """No-op input validator."""

  ### Ancestors

  - Validator

  ### Inherited members

  - `Validator`:
    - `assert_valid`
`class RenounceMinterMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the renounceMinter method.

  Persist instance data.

  Expand source code

      class RenounceMinterMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the renounceMinter method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters
              :returns: the return value of the underlying method.

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> NoneType`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters :returns: the return value of the underlying method.

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> None:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        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: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  `def send_transaction(self, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class SymbolMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the symbol method.

  Persist instance data.

  Expand source code

      class SymbolMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the symbol method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              returned = _fn.call({
                  'from': self._operate
              })
              return str(returned)

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> str`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return str(returned)

  `def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class TokenNameMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the tokenName method.

  Persist instance data.

  Expand source code

      class TokenNameMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the tokenName method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              returned = _fn.call({
                  'from': self._operate
              })
              return str(returned)

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> str`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return str(returned)

  `def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class TokenSymbolMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the tokenSymbol method.

  Persist instance data.

  Expand source code

      class TokenSymbolMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the tokenSymbol method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              returned = _fn.call({
                  'from': self._operate
              })
              return str(returned)

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> str`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> str:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return str(returned)

  `def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class TotalSupplyMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction)`

  Various interfaces to the totalSupply method.

  Persist instance data.

  Expand source code

      class TotalSupplyMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the totalSupply method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction):
              """Persist instance data."""
              super().__init__(elib, contract_address)
              self._underlying_method = contract_function

          def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method().call(tx_params.as_dict())

              """
              _fn = self._underlying_method()

              returned = _fn.call({
                  'from': self._operate
              })
              return int(returned)

          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())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> int`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method().call(tx_params.as_dict())

    Expand source code

        def block_call(self, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> int:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method().call(tx_params.as_dict())

            """
            _fn = self._underlying_method()

            returned = _fn.call({
                'from': self._operate
            })
            return int(returned)

  `def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        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())

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class TransferFromMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the transferFrom method.

  Persist instance data.

  Expand source code

      class TransferFromMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the transferFrom method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          def validate_and_normalize_inputs(self, sender: str, recipient: str, amount: int):
              """Validate the inputs to the transferFrom method."""
              self.validator.assert_valid(
                  method_name='transferFrom',
                  parameter_name='sender',
                  argument_value=sender,
              )
              sender = self.validate_and_checksum_address(sender)
              self.validator.assert_valid(
                  method_name='transferFrom',
                  parameter_name='recipient',
                  argument_value=recipient,
              )
              recipient = self.validate_and_checksum_address(recipient)
              self.validator.assert_valid(
                  method_name='transferFrom',
                  parameter_name='amount',
                  argument_value=amount,
              )
              # safeguard against fractional inputs
              amount = int(amount)
              return (sender, recipient, amount)

          def block_call(self, sender: str, recipient: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters
              :returns: the return value of the underlying method.

              (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(sender, recipient, amount).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(sender, recipient, amount)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          def send_transaction(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
              """Execute underlying contract method via eth_sendTransaction.

              :param tx_params: transaction parameters
              """
              (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(sender, recipient, amount).transact(tx_params.as_dict())

          def build_transaction(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
              """Construct calldata to be used as input to the method."""
              (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(sender, recipient, amount).buildTransaction(tx_params.as_dict())

          def estimate_gas(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
              """Estimate gas consumption of method call."""
              (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(sender, recipient, amount).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, sender: str, recipient: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> bool`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters :returns: the return value of the underlying method.

    (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(sender, recipient, amount).call(tx_params.as_dict())

    Expand source code

        def block_call(self, sender: str, recipient: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(sender, recipient, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(sender, recipient, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, sender: str, recipient: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        def build_transaction(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
            """Construct calldata to be used as input to the method."""
            (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(sender, recipient, amount).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, sender: str, recipient: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        def estimate_gas(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
            """Estimate gas consumption of method call."""
            (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(sender, recipient, amount).estimateGas(tx_params.as_dict())

  `def send_transaction(self, sender: str, recipient: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        def send_transaction(self, sender: str, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :param tx_params: transaction parameters
            """
            (sender, recipient, amount) = self.validate_and_normalize_inputs(sender, recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(sender, recipient, amount).transact(tx_params.as_dict())

  `def validate_and_normalize_inputs(self, sender: str, recipient: str, amount: int)`

    Validate the inputs to the transferFrom method.

    Expand source code

        def validate_and_normalize_inputs(self, sender: str, recipient: str, amount: int):
            """Validate the inputs to the transferFrom method."""
            self.validator.assert_valid(
                method_name='transferFrom',
                parameter_name='sender',
                argument_value=sender,
            )
            sender = self.validate_and_checksum_address(sender)
            self.validator.assert_valid(
                method_name='transferFrom',
                parameter_name='recipient',
                argument_value=recipient,
            )
            recipient = self.validate_and_checksum_address(recipient)
            self.validator.assert_valid(
                method_name='transferFrom',
                parameter_name='amount',
                argument_value=amount,
            )
            # safeguard against fractional inputs
            amount = int(amount)
            return (sender, recipient, amount)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`
`class TransferMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)`

  Various interfaces to the transfer method.

  Persist instance data.

  Expand source code

      class TransferMethod(ContractMethod):  # pylint: disable=invalid-name
          """Various interfaces to the transfer method."""

          def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
              """Persist instance data."""
              super().__init__(elib, contract_address, validator)
              self._underlying_method = contract_function

          def validate_and_normalize_inputs(self, recipient: str, amount: int):
              """Validate the inputs to the transfer method."""
              self.validator.assert_valid(
                  method_name='transfer',
                  parameter_name='recipient',
                  argument_value=recipient,
              )
              recipient = self.validate_and_checksum_address(recipient)
              self.validator.assert_valid(
                  method_name='transfer',
                  parameter_name='amount',
                  argument_value=amount,
              )
              # safeguard against fractional inputs
              amount = int(amount)
              return (recipient, amount)

          def block_call(self, recipient: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
              """Execute underlying contract method via eth_call.

              :param tx_params: transaction parameters
              :returns: the return value of the underlying method.

              (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)

              tx_params: Optional[TxParams] = None
              tx_params = super().normalize_tx_params(tx_params)

              returned = self._underlying_method(recipient, amount).call(tx_params.as_dict())

              """
              _fn = self._underlying_method(recipient, amount)

              _t = _fn.buildTransaction({
                  'from': self._operate
              })
              _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

              if val > 0:
                  _t['value'] = val

              if debug:
                  print(f"======== Signing ✅ by {self._operate}")
                  print(f"======== Transaction ✅ check")
                  print(_t)

              if 'data' in _t:

                  signed = self._web3_eth.account.sign_transaction(_t)
                  txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                  if enforcereci is True:
                      print("======== Wait for confirmation 🚸️")
                      tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                      print("======== TX Result ✅")
                      print(tx_receipt)
                      if debug:
                          print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

          def send_transaction(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
              """Execute underlying contract method via eth_sendTransaction.

              :param tx_params: transaction parameters
              """
              (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(recipient, amount).transact(tx_params.as_dict())

          def build_transaction(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
              """Construct calldata to be used as input to the method."""
              (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(recipient, amount).buildTransaction(tx_params.as_dict())

          def estimate_gas(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
              """Estimate gas consumption of method call."""
              (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
              tx_params = super().normalize_tx_params(tx_params)
              return self._underlying_method(recipient, amount).estimateGas(tx_params.as_dict())

  ### Ancestors

  - ContractMethod

  ### Methods

  `def block_call(self, recipient: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) ‑> bool`

    Execute underlying contract method via eth_call.

    :param tx_params: transaction parameters :returns: the return value of the underlying method.

    (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)

    tx_params: Optional[TxParams] = None tx_params = super().normalize_tx_params(tx_params)

    returned = self._underlying_method(recipient, amount).call(tx_params.as_dict())

    Expand source code

        def block_call(self, recipient: str, amount: int, val: int = 0, fee: int = 1000000, debug: bool = False, enforcereci: bool = False) -> bool:
            """Execute underlying contract method via eth_call.

            :param tx_params: transaction parameters
            :returns: the return value of the underlying method.

            (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)

            tx_params: Optional[TxParams] = None
            tx_params = super().normalize_tx_params(tx_params)

            returned = self._underlying_method(recipient, amount).call(tx_params.as_dict())

            """
            _fn = self._underlying_method(recipient, amount)

            _t = _fn.buildTransaction({
                'from': self._operate
            })
            _t['nonce'] = self._web3_eth.getTransactionCount(self._operate)

            if val > 0:
                _t['value'] = val

            if debug:
                print(f"======== Signing ✅ by {self._operate}")
                print(f"======== Transaction ✅ check")
                print(_t)

            if 'data' in _t:

                signed = self._web3_eth.account.sign_transaction(_t)
                txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)

                if enforcereci is True:
                    print("======== Wait for confirmation 🚸️")
                    tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
                    print("======== TX Result ✅")
                    print(tx_receipt)
                    if debug:
                        print(f"======== TX blockHash ✅ {tx_receipt.blockHash}")

  `def build_transaction(self, recipient: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict`

    Construct calldata to be used as input to the method.

    Expand source code

        def build_transaction(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
            """Construct calldata to be used as input to the method."""
            (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(recipient, amount).buildTransaction(tx_params.as_dict())

  `def estimate_gas(self, recipient: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> int`

    Estimate gas consumption of method call.

    Expand source code

        def estimate_gas(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
            """Estimate gas consumption of method call."""
            (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(recipient, amount).estimateGas(tx_params.as_dict())

  `def send_transaction(self, recipient: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]`

    Execute underlying contract method via eth_sendTransaction.

    :param tx_params: transaction parameters

    Expand source code

        def send_transaction(self, recipient: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
            """Execute underlying contract method via eth_sendTransaction.

            :param tx_params: transaction parameters
            """
            (recipient, amount) = self.validate_and_normalize_inputs(recipient, amount)
            tx_params = super().normalize_tx_params(tx_params)
            return self._underlying_method(recipient, amount).transact(tx_params.as_dict())

  `def validate_and_normalize_inputs(self, recipient: str, amount: int)`

    Validate the inputs to the transfer method.

    Expand source code

        def validate_and_normalize_inputs(self, recipient: str, amount: int):
            """Validate the inputs to the transfer method."""
            self.validator.assert_valid(
                method_name='transfer',
                parameter_name='recipient',
                argument_value=recipient,
            )
            recipient = self.validate_and_checksum_address(recipient)
            self.validator.assert_valid(
                method_name='transfer',
                parameter_name='amount',
                argument_value=amount,
            )
            # safeguard against fractional inputs
            amount = int(amount)
            return (recipient, amount)

  ### Inherited members

  - `ContractMethod`:
    - `normalize_tx_params`
    - `validate_and_checksum_address`