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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Inherited members

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

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

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

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

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

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

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

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

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

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

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

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

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

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