Asyncify contract

conftest.py

@@ -1,3 +1,4 @@
+import asyncio
 import pytest
 import time
 import warnings
@@ -9,6 +10,7 @@
     Web3,
 )
 from web3.providers.eth_tester import (
+    AsyncEthereumTesterProvider,
     EthereumTesterProvider,
 )
 
@@ -44,6 +46,10 @@ def is_testrpc_provider(provider):
     return isinstance(provider, EthereumTesterProvider)
 
 
+def is_async_testrpc_provider(provider):
+    return isinstance(provider, AsyncEthereumTesterProvider)
+
+
 @pytest.fixture()
 def skip_if_testrpc():
 
@@ -53,6 +59,15 @@ def _skip_if_testrpc(w3):
     return _skip_if_testrpc
 
 
+@pytest.fixture()
+def async_skip_if_testrpc():
+
+    def _skip_if_testrpc(async_w3):
+        if is_async_testrpc_provider(async_w3.provider):
+            pytest.skip()
+    return _skip_if_testrpc
+
+
 @pytest.fixture()
 def wait_for_miner_start():
     def _wait_for_miner_start(w3, timeout=60):

docs/contracts.rst

@@ -244,7 +244,7 @@ Each Contract Factory exposes the following methods.
         >>> txn_receipt['contractAddress']
         '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318'
 
-.. py:classmethod:: Contract.constructor(*args, **kwargs).estimateGas(transaction=None, block_identifier=None)
+.. py:classmethod:: Contract.constructor(*args, **kwargs).estimate_gas(transaction=None, block_identifier=None)
     :noindex:
 
     Estimate gas for constructing and deploying the contract.
@@ -264,12 +264,12 @@ Each Contract Factory exposes the following methods.
 
     .. code-block:: python
 
-        >>> token_contract.constructor(web3.eth.coinbase, 12345).estimateGas()
+        >>> token_contract.constructor(web3.eth.coinbase, 12345).estimate_gas()
         12563
 
-.. py:classmethod:: Contract.constructor(*args, **kwargs).buildTransaction(transaction=None)
+.. py:classmethod:: Contract.constructor(*args, **kwargs).build_transaction(transaction=None)
     :noindex:
-
+    
     Construct the contract deploy transaction bytecode data.
 
     If the contract takes constructor parameters they should be provided as
@@ -286,7 +286,7 @@ Each Contract Factory exposes the following methods.
         'gasPrice': w3.eth.gas_price,
         'chainId': None
         }
-        >>> contract_data = token_contract.constructor(web3.eth.coinbase, 12345).buildTransaction(transaction)
+        >>> contract_data = token_contract.constructor(web3.eth.coinbase, 12345).build_transaction(transaction)
         >>> web3.eth.send_transaction(contract_data)
 
 .. _contract_createFilter:
@@ -833,7 +833,7 @@ Methods
     a "missing trie node" error, because Ethereum node may have purged the past state from its database.
     `More information about archival nodes here <https://ethereum.stackexchange.com/a/84200/620>`_.
 
-.. py:method:: ContractFunction.estimateGas(transaction, block_identifier=None)
+.. py:method:: ContractFunction.estimate_gas(transaction, block_identifier=None)
 
     Call a contract function, executing the transaction locally using the
     ``eth_call`` API.  This will not create a new public transaction.
@@ -842,7 +842,7 @@ Methods
 
     .. code-block:: python
 
-        myContract.functions.myMethod(*args, **kwargs).estimateGas(transaction)
+        myContract.functions.myMethod(*args, **kwargs).estimate_gas(transaction)
 
     This method behaves the same as the :py:meth:`ContractFunction.transact` method,
     with transaction details being passed into the end portion of the
@@ -853,23 +853,23 @@ Methods
 
     .. code-block:: python
 
-        >>> my_contract.functions.multiply7(3).estimateGas()
+        >>> my_contract.functions.multiply7(3).estimate_gas()
         42650
 
     .. note::
         The parameter ``block_identifier`` is not enabled in geth nodes,
         hence passing a value of ``block_identifier`` when connected to a geth
         nodes would result in an error like:  ``ValueError: {'code': -32602, 'message': 'too many arguments, want at most 1'}``
-
-.. py:method:: ContractFunction.buildTransaction(transaction)
+  
+.. py:method:: ContractFunction.build_transaction(transaction)
 
     Builds a transaction dictionary based on the contract function call specified.
 
     Refer to the following invocation:
 
     .. code-block:: python
 
-        myContract.functions.myMethod(*args, **kwargs).buildTransaction(transaction)
+        myContract.functions.myMethod(*args, **kwargs).build_transaction(transaction)
 
     This method behaves the same as the :py:meth:`Contract.transact` method,
     with transaction details being passed into the end portion of the
@@ -881,15 +881,15 @@ Methods
 
         .. code-block:: python
 
-            >>> math_contract.functions.increment(5).buildTransaction({'nonce': 10})
+            >>> math_contract.functions.increment(5).build_transaction({'nonce': 10})
 
         You may use :meth:`~web3.eth.Eth.getTransactionCount` to get the current nonce
         for an account. Therefore a shortcut for producing a transaction dictionary with
         nonce included looks like:
 
         .. code-block:: python
 
-            >>> math_contract.functions.increment(5).buildTransaction({'nonce': web3.eth.get_transaction_count('0xF5...')})
+            >>> math_contract.functions.increment(5).build_transaction({'nonce': web3.eth.get_transaction_count('0xF5...')})
 
     Returns a transaction dictionary. This transaction dictionary can then be sent using
     :meth:`~web3.eth.Eth.send_transaction`.
@@ -899,7 +899,7 @@ Methods
 
     .. code-block:: python
 
-        >>> math_contract.functions.increment(5).buildTransaction({'maxFeePerGas': 2000000000, 'maxPriorityFeePerGas': 1000000000})
+        >>> math_contract.functions.increment(5).build_transaction({'maxFeePerGas': 2000000000, 'maxPriorityFeePerGas': 1000000000})
         {
             'to': '0x6Bc272FCFcf89C14cebFC57B8f1543F5137F97dE',
             'data': '0x7cf5dab00000000000000000000000000000000000000000000000000000000000000005',
@@ -923,15 +923,15 @@ Fallback Function
     Call fallback function, executing the transaction locally using the
     ``eth_call`` API.  This will not create a new public transaction.
 
-.. py:method:: Contract.fallback.estimateGas(transaction)
+.. py:method:: Contract.fallback.estimate_gas(transaction)
 
     Call fallback function and return the gas estimation.
 
 .. py:method:: Contract.fallback.transact(transaction)
 
     Execute fallback function by sending a new public transaction.
 
-.. py:method:: Contract.fallback.buildTransaction(transaction)
+.. py:method:: Contract.fallback.build_transaction(transaction)
 
     Builds a transaction dictionary based on the contract fallback function call.
 

docs/examples.rst

@@ -361,7 +361,7 @@ The following example demonstrates a few things:
 
     store_var_contract = w3.eth.contract(address=address, abi=contract_interface["abi"])
 
-    gas_estimate = store_var_contract.functions.setVar(255).estimateGas()
+    gas_estimate = store_var_contract.functions.setVar(255).estimate_gas()
     print(f'Gas estimate to transact with setVar: {gas_estimate}')
 
     if gas_estimate < 100000:
@@ -674,7 +674,7 @@ Just remember that you have to sign all transactions locally, as infura does not
 
 .. code-block:: python
 
-    transaction = contract.functions.function_Name(params).buildTransaction()
+    transaction = contract.functions.function_Name(params).build_transaction()
     transaction.update({ 'gas' : appropriate_gas_amount })
     transaction.update({ 'nonce' : w3.eth.get_transaction_count('Your_Wallet_Address') })
     signed_tx = w3.eth.account.sign_transaction(transaction, private_key)

docs/providers.rst

@@ -468,6 +468,12 @@ Geth
 - :meth:`web3.geth.txpool.content() <web3.geth.txpool.TxPool.content()>`
 - :meth:`web3.geth.txpool.status() <web3.geth.txpool.TxPool.status()>`
 
+Contract
+^^^^^^^^
+Contract is fully implemented for the Async provider. The only documented exception to this at 
+the moment is where :class:`ENS` is needed for address lookup. All addresses that are passed to Async
+contract should not be :class:`ENS` addresses. 
+
 Supported Middleware
 ^^^^^^^^^^^^^^^^^^^^
 - :meth:`Gas Price Strategy <web3.middleware.gas_price_strategy_middleware>`

docs/web3.eth.account.rst

@@ -361,7 +361,7 @@ To sign a transaction locally that will invoke a smart contract:
     >>> unicorn_txn = unicorns.functions.transfer(
     ...     '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
     ...     1,
-    ... ).buildTransaction({
+    ... ).build_transaction({
     ...     'chainId': 1,
     ...     'gas': 70000,
     ...     'maxFeePerGas': w3.toWei('2', 'gwei'),

ens/main.py

@@ -67,6 +67,7 @@
 if TYPE_CHECKING:
     from web3 import Web3  # noqa: F401
     from web3.contract import (  # noqa: F401
+        AsyncContract,
         Contract,
     )
     from web3.providers import (  # noqa: F401
@@ -232,7 +233,7 @@ def setup_address(
         if address is None:
             address = EMPTY_ADDR_HEX
         transact['from'] = owner
-        resolver: 'Contract' = self._set_resolver(name, transact=transact)
+        resolver: Union['Contract', 'AsyncContract'] = self._set_resolver(name, transact=transact)
         return resolver.functions.setAddr(raw_name_to_hash(name), address).transact(transact)
 
     def setup_name(
@@ -285,7 +286,7 @@ def setup_name(
                 self.setup_address(name, address, transact=transact)
             return self._setup_reverse(name, address, transact=transact)
 
-    def resolver(self, name: str) -> Optional['Contract']:
+    def resolver(self, name: str) -> Optional[Union['Contract', 'AsyncContract']]:
         """
         Get the resolver for an ENS name.
 
@@ -294,7 +295,8 @@ def resolver(self, name: str) -> Optional['Contract']:
         normal_name = normalize_name(name)
         return self._get_resolver(normal_name)[0]
 
-    def reverser(self, target_address: ChecksumAddress) -> Optional['Contract']:
+    def reverser(self,
+                 target_address: ChecksumAddress) -> Optional[Union['Contract', 'AsyncContract']]:
         reversed_domain = address_to_reverse_domain(target_address)
         return self.resolver(reversed_domain)
 
@@ -511,7 +513,7 @@ def _set_resolver(
         name: str,
         resolver_addr: Optional[ChecksumAddress] = None,
         transact: Optional["TxParams"] = None
-    ) -> 'Contract':
+    ) -> Union['Contract', 'AsyncContract']:
         if not transact:
             transact = {}
         transact = deepcopy(transact)
@@ -529,7 +531,7 @@ def _get_resolver(
         self,
         normal_name: str,
         fn_name: str = 'addr'
-    ) -> Tuple[Optional['Contract'], str]:
+    ) -> Tuple[Optional[Union['Contract', 'AsyncContract']], str]:
         current_name = normal_name
 
         # look for a resolver, starting at the full name and taking the parent each time that no
@@ -549,7 +551,8 @@ def _get_resolver(
             current_name = self.parent(current_name)
 
     def _decode_ensip10_resolve_data(
-        self, contract_call_result: bytes, extended_resolver: 'Contract', fn_name: str,
+        self, contract_call_result: bytes,
+        extended_resolver: Union['Contract', 'AsyncContract'], fn_name: str,
     ) -> Any:
         func = extended_resolver.get_function_by_name(fn_name)
         output_types = get_abi_output_types(func.abi)
@@ -568,18 +571,21 @@ def _setup_reverse(
         transact['from'] = address
         return self._reverse_registrar().functions.setName(name).transact(transact)
 
-    def _type_aware_resolver(self, address: ChecksumAddress, func: str) -> 'Contract':
+    def _type_aware_resolver(self,
+                             address: ChecksumAddress,
+                             func: str) -> Union['Contract', 'AsyncContract']:
         return (
             self._reverse_resolver_contract(address=address) if func == 'name' else
             self._resolver_contract(address=address)
         )
 
-    def _reverse_registrar(self) -> 'Contract':
+    def _reverse_registrar(self) -> Union['Contract', 'AsyncContract']:
         addr = self.ens.caller.owner(normal_name_to_hash(REVERSE_REGISTRAR_DOMAIN))
         return self.w3.eth.contract(address=addr, abi=abis.REVERSE_REGISTRAR)
 
 
-def _resolver_supports_interface(resolver: 'Contract', interface_id: HexStr) -> bool:
+def _resolver_supports_interface(resolver: Union['Contract', 'AsyncContract'],
+                                 interface_id: HexStr) -> bool:
     if not any('supportsInterface' in repr(func) for func in resolver.all_functions()):
         return False
     return resolver.caller.supportsInterface(interface_id)

ethpm/package.py

@@ -309,7 +309,8 @@ def get_contract_instance(self, name: ContractName, address: Address) -> Contrac
         contract_instance = self.w3.eth.contract(
             address=address, **contract_kwargs
         )
-        return contract_instance
+        # TODO: type ignore may be able to be removed after more of AsyncContract is finished
+        return contract_instance  # type: ignore
 
     #
     # Build Dependencies

newsfragments/2270.feature.rst

@@ -0,0 +1 @@
+Add async version of contract functionality

tests/core/conftest.py

@@ -1,8 +1,17 @@
 import pytest
 
+import pytest_asyncio
+
+from web3 import Web3
+from web3.eth import (
+    AsyncEth,
+)
 from web3.module import (
     Module,
 )
+from web3.providers.eth_tester.main import (
+    AsyncEthereumTesterProvider,
+)
 
 # --- inherit from `web3.module.Module` class --- #
 
@@ -97,3 +106,22 @@ def __init__(self, a, b):
             self.a = a
             self.b = b
     return ModuleManyArgs
+
+
+@pytest_asyncio.fixture()
+async def async_w3():
+    provider = AsyncEthereumTesterProvider()
+    w3 = Web3(provider, modules={'eth': [AsyncEth]},
+              middlewares=provider.middlewares)
+    w3.eth.default_account = await w3.eth.coinbase
+    return w3
+
+
+@pytest_asyncio.fixture()
+async def async_w3_strict_abi():
+    provider = AsyncEthereumTesterProvider()
+    w3 = Web3(provider, modules={'eth': [AsyncEth]},
+              middlewares=provider.middlewares)
+    w3.enable_strict_bytes_type_checking()
+    w3.eth.default_account = await w3.eth.coinbase
+    return w3

tests/core/contracts/_utils.py

@@ -0,0 +1,39 @@
+import asyncio
+
+from eth_utils.toolz import (
+    identity,
+)
+
+
+def deploy(w3, Contract, apply_func=identity, args=None):
+    args = args or []
+    deploy_txn = Contract.constructor(*args).transact()
+    deploy_receipt = w3.eth.wait_for_transaction_receipt(deploy_txn)
+    assert deploy_receipt is not None
+    address = apply_func(deploy_receipt['contractAddress'])
+    contract = Contract(address=address)
+    assert contract.address == address
+    assert len(w3.eth.get_code(contract.address)) > 0
+    return contract
+
+
+async def async_deploy(async_web3, Contract, apply_func=identity, args=None):
+    args = args or []
+    deploy_txn = await Contract.constructor(*args).transact()
+    deploy_receipt = await async_web3.eth.wait_for_transaction_receipt(deploy_txn)
+    assert deploy_receipt is not None
+    address = apply_func(deploy_receipt['contractAddress'])
+    contract = Contract(address=address)
+    assert contract.address == address
+    assert len(await async_web3.eth.get_code(contract.address)) > 0
+    return contract
+
+
+def async_partial(f, *args, **kwargs):
+    async def f2(*args2, **kwargs2):
+        result = f(*args, *args2, **kwargs, **kwargs2)
+        if asyncio.iscoroutinefunction(f):
+            result = await result
+        return result
+
+    return f2