eth-prototype 0.7.5__py3-none-any.whl → 1.0.1__py3-none-any.whl

{eth_prototype-0.7.5.dist-info → eth_prototype-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eth-prototype
-Version: 0.7.5
+Version: 1.0.1
 Summary: Prototype Ethereum Smart Contracts in Python
 Home-page: https://github.com/gnarvaja/eth-prototype
 Author: Guillermo M. Narvaja
@@ -11,15 +11,14 @@ Platform: any
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Requires-Python: >=3.7
-Description-Content-Type: text/x-rst; charset=UTF-8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 License-File: LICENSE.txt
 License-File: AUTHORS.rst
 Requires-Dist: m9g
 Requires-Dist: environs
 Requires-Dist: requests
+Requires-Dist: hexbytes
 Requires-Dist: importlib-metadata ; python_version < "3.8"
-Provides-Extra: brownie
-Requires-Dist: eth-brownie ; extra == 'brownie'
 Provides-Extra: defender
 Requires-Dist: boto3 ; extra == 'defender'
 Provides-Extra: gmpy2
@@ -29,74 +28,46 @@ Requires-Dist: setuptools ; extra == 'testing'
 Requires-Dist: pytest ; extra == 'testing'
 Requires-Dist: gmpy2 ; extra == 'testing'
 Requires-Dist: pytest-cov ; extra == 'testing'
-Provides-Extra: testing-br
-Requires-Dist: eth-brownie ; extra == 'testing-br'
-Requires-Dist: setuptools ; extra == 'testing-br'
-Requires-Dist: pytest ; extra == 'testing-br'
-Requires-Dist: pytest-cov ; extra == 'testing-br'
 Provides-Extra: testing-w3
-Requires-Dist: web3[tester] ; extra == 'testing-w3'
+Requires-Dist: web3[tester] >=6 ; extra == 'testing-w3'
 Requires-Dist: setuptools ; extra == 'testing-w3'
 Requires-Dist: pytest ; extra == 'testing-w3'
-Requires-Dist: eth-event ; extra == 'testing-w3'
 Requires-Dist: pytest-cov ; extra == 'testing-w3'
 Requires-Dist: boto3 ; extra == 'testing-w3'
 Provides-Extra: web3
-Requires-Dist: web3 ; extra == 'web3'
-Requires-Dist: eth-event ; extra == 'web3'
+Requires-Dist: web3 >=6 ; extra == 'web3'
 
-=============
-eth-prototype
-=============
+# eth-prototype
 
 
 Prototype Ethereum Smart Contracts in Python
 
 
-Description
-===========
+## Description
 
 Library with base classes to prototype Ethereum Smart Contracts in Python. This includes:
 
 - wadray: classes for fixed number of decimals math implemented with integers.
 - contracts: classes to simulate contracts in Python with features like *rollback* on exception, external
   methods, views. Also classes for common contracts like ERC20 (tokens), ERC721 (NFTs) and AccessControl.
-- brwrappers: classes to wrap ethereum contracts called thru [brownie](https://github.com/eth-brownie/brownie/) but with a pythonic interface
 - w3wrappers: classes to wrap ethereum contracts called thru [web3py](https://web3py.readthedocs.io/) but with a pythonic interface
 
+To use the `defender_relay` module you need to have the `warrant` package from this repo: https://github.com/gnarvaja/warrant. Add it to your requirements.txt as:
 
-Tox Tests
-=========
+```
+warrant @ git+https://github.com/gnarvaja/warrant.git#egg=warrant
+```
 
-The tox tests run in three variants:
+Note that using the `warrant` package from pypi will not work because of incompatibilities with newer python versions.
 
-- `default`: only uses and tests the prototype libraries, no blockchain.
-- `default-w3`: users and tests two variants: prototype and w3wrappers (wrappers using web3py).
-- `default-br`: users and tests two variants: prototype and brwrappers (wrappers using brownie).
-
-It's not possible for now running all the tests together because of incompatibilities between brownie and web3[tester].
-
-
-To run the tox `default-br` tests, you need an environment with Brownie, SOLC and other requirements.
+## Tox Tests
 
-You can do it using a Docker image an a few commands
+The tox tests run in two variants:
 
-.. code-block:: bash
-
-   docker run -it -v $PWD:/code -w /code gnarvaja/eth-dev:1.0.0 bash
-   gnarvaja/eth-dev:eth-proto-brownie
-   pip install tox
-   brownie pm install OpenZeppelin/openzeppelin-contracts@4.3.2
-   brownie pm install OpenZeppelin/openzeppelin-contracts-upgradeable@4.3.2
-   tox -e py39-br
-
-   docker run -it -v $PWD:/code -w /code gnarvaja/eth-dev:eth-proto-brownie bash
-   tox -e py39-br
-
-.. _pyscaffold-notes:
+- `default`: only uses and tests the prototype libraries, no blockchain.
+- `default-w3`: users and tests two variants: prototype and w3wrappers (wrappers using web3py).
 
-Note
-====
+# Note
 
 This project has been set up using PyScaffold 4.0.2. For details and usage
 information on PyScaffold see https://pyscaffold.org/.

eth_prototype-1.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+ethproto/__init__.py,sha256=YWkAFysBp4tZjLWWB2FFmp5yG23pUYhQvgQW9b3soXs,579
+ethproto/build_artifacts.py,sha256=FzgUO6ierhCVBKHRxTkgrRx4AaAL6G5ql5Yzx_oTTmg,5578
+ethproto/contracts.py,sha256=rNVbCK1hURy7lWKhzSdXgVWo3wx9O_Ghk-6PfgOsRNk,18662
+ethproto/defender_relay.py,sha256=05A8TfRZwiBhCpo924Pf9CjfKSir2Wvgg1p_asFxJbw,1777
+ethproto/w3wrappers.py,sha256=MrRf7GLFgDhKYKiTctjNONZHQNTo6nVzqPzprv0BU2w,20607
+ethproto/wadray.py,sha256=JBsu5KcyU9k70bDK03T2IY6qPVFO30WbYPhwrAHdXao,8262
+ethproto/wrappers.py,sha256=9qDwRDOXw3wquzvGfIsub-VPWm98GBWP7dHLFOUPWzg,17307
+eth_prototype-1.0.1.dist-info/AUTHORS.rst,sha256=Ui-05yYXtDZxna6o1yNcfdm8Jt68UIDQ01osiLxlYlU,95
+eth_prototype-1.0.1.dist-info/LICENSE.txt,sha256=U_Q6_nDYDwZPIuhttHi37hXZ2qU2-HlV2geo9hzHXFw,1087
+eth_prototype-1.0.1.dist-info/METADATA,sha256=TE-gm2NZKjLg7mgbihmuddG0XwORT7DrAM8UqtLPMtg,2669
+eth_prototype-1.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+eth_prototype-1.0.1.dist-info/top_level.txt,sha256=Dl0X7m6N1hxeo4JpGpSNqWC2gtsN0731g-DL1J0mpjc,9
+eth_prototype-1.0.1.dist-info/RECORD,,

{eth_prototype-0.7.5.dist-info → eth_prototype-1.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ethproto/build_artifacts.py

@@ -0,0 +1,152 @@
+"""Helper classes to use hardhat build artifacts from python"""
+
+
+import json
+import os
+import os.path
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Union, Tuple
+
+LIBRARY_PLACEHOLDER_MATCHER = re.compile(r"__\$[0-9a-f]{34}\$__")
+
+
+@dataclass
+class Artifact:
+    contract_name: str
+    abi: list
+    bytecode: str
+    deployed_bytecode: str
+    link_references: dict
+    deployed_link_references: dict
+
+    def __init__(self, **kwargs):
+        self.contract_name = kwargs["contractName"]
+        self.abi = kwargs["abi"]
+        self.bytecode = kwargs["bytecode"]
+        self.deployed_bytecode = kwargs["deployedBytecode"]
+        self.link_references = kwargs["linkReferences"]
+        self.deployed_link_references = kwargs["deployedLinkReferences"]
+
+    def link(self, libraries: dict) -> "Artifact":
+        """Returns a new artifact with the external libraries linked
+
+        Libraries is a dictionary of the form {library_name: address}
+        """
+        bytecode = self._replace_link_references(
+            self.bytecode, self.link_references, libraries
+        )
+        deployed_bytecode = self._replace_link_references(
+            self.deployed_bytecode, self.deployed_link_references, libraries
+        )
+        return Artifact(
+            contractName=self.contract_name,
+            abi=self.abi,
+            bytecode=bytecode,
+            deployedBytecode=deployed_bytecode,
+            linkReferences=self.link_references,
+            deployedLinkReferences=self.deployed_link_references,
+        )
+
+    def libraries(self) -> Tuple[str, str]:
+        """Generates a tuple of (library, source) for each library reference in the artifact"""
+        for source, libs in self.link_references.items():
+            for lib in libs.keys():
+                yield lib, source
+
+    def _replace_link_references(
+        self, bytecode: str, link_references: dict, libraries: dict
+    ) -> str:
+        # remove 0x prefix if present
+        bytecode = bytecode[2:] if bytecode.startswith("0x") else bytecode
+
+        for libs in link_references.values():
+            for lib, lib_refs in libs.items():
+                try:
+                    address = libraries[lib]
+                except KeyError:
+                    raise ValueError(f"Missing library address for {lib}")
+                address = address[2:] if address.startswith("0x") else address
+
+                assert len(address) == 40  # Sanity check
+
+                for ref in lib_refs:
+                    # 2 nibbles -> 1 byte
+                    start = ref["start"] * 2
+                    length = ref["length"] * 2
+
+                    # Sanity check
+                    assert LIBRARY_PLACEHOLDER_MATCHER.match(
+                        bytecode[start : start + length]
+                    ), f"Unexpected placeholder at position {start}: {bytecode[start:start + length]}"
+
+                    # Replace the placeholder with the actual address
+                    bytecode = bytecode[:start] + address + bytecode[start + length :]
+
+        # Return value always has 0x prefix
+        return "0x" + bytecode
+
+    def __str__(self):
+        return f"Artifact({self.contract_name})"
+
+    def __repr__(self):
+        return f"Artifact({self.contract_name})"
+
+
+class ArtifactLibrary:
+    def __init__(self, *paths: Tuple[Union[str, Path]]):
+        self.lookup_paths = [Path(p).absolute() for p in paths]
+        self._fullpath_cache = {}
+        self._name_cache = {}
+
+    def get_artifact(self, contract: str) -> Artifact:
+        """Returns a build artifact by full contract path
+
+        This method is compatible with hardhat's artifact structure.
+
+        Examples:
+
+        >>> library = ArtifactLibrary("./artifacts")
+        >>> counter_build = library.get_artifact("contracts/Counter.sol")
+        >>> proxy_build = library.get_artifact("@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol")
+        """
+        contract = Path(os.path.normpath(contract))
+
+        if contract not in self._fullpath_cache:
+            for path in self.lookup_paths:
+                build_artifact_path = (
+                    path / contract / contract.with_suffix(".json").name
+                )
+                if build_artifact_path.exists():
+                    with open(build_artifact_path) as f:
+                        self._fullpath_cache[contract] = Artifact(**json.load(f))
+
+            if contract not in self._fullpath_cache:
+                raise FileNotFoundError(
+                    f"Could not find artifact for {contract} on {self.lookup_paths}"
+                )
+
+        return self._fullpath_cache[contract]
+
+    def get_artifact_by_name(self, contract_name: str) -> Artifact:
+        """Returns a build artifact by looking for a matching contract name
+
+        Example:
+
+        >>> library = ArtifactLibrary("./artifacts")
+        >>> counter_build = library.get_artifact_by_name("Counter")
+        """
+        if contract_name not in self._name_cache:
+            for path in self.lookup_paths:
+                for dirpath, _, filenames in os.walk(path):
+                    if f"{contract_name}.json" in filenames:
+                        with open(Path(dirpath) / f"{contract_name}.json") as f:
+                            self._name_cache[contract_name] = Artifact(**json.load(f))
+
+            if contract_name not in self._name_cache:
+                raise FileNotFoundError(
+                    f"Could not find artifact for {contract_name} on {self.lookup_paths}"
+                )
+
+        return self._name_cache[contract_name]

ethproto/contracts.py

@@ -1,11 +1,13 @@
 import os
 import time
+from contextlib import contextmanager
 from decimal import Decimal
 from functools import wraps
-from contextlib import contextmanager
+
 from m9g import Model
-from m9g.fields import IntField, DictField, StringField, TupleField, ListField
-from .wadray import Wad, Ray
+from m9g.fields import DictField, IntField, ListField, StringField, TupleField
+
+from .wadray import Ray, Wad
 
 __author__ = "Guillermo M. Narvaja"
 __copyright__ = "Guillermo M. Narvaja"
@@ -501,7 +503,7 @@ class ERC721Token(AccessControlContract):   # NFT
     @view
     def owner_of(self, token_id):
         if token_id not in self.owners:
-            raise RevertError("ERC721: owner query for nonexistent token")
+            raise RevertError("ERC721: invalid token ID")
         return self.owners[token_id]
 
     # def token_uri
@@ -536,7 +538,7 @@ class ERC721Token(AccessControlContract):   # NFT
         owner = self.owners[token_id]
         if sender != owner and self.token_approvals.get(token_id, None) != sender and \
                 sender not in self.operator_approvals.get(owner, []):
-            raise RevertError("ERC721: transfer caller is not owner nor approved")
+            raise RevertError("ERC721: caller is not token owner or approved")
         return self._transfer(from_, to, token_id)
 
     @external
@@ -544,7 +546,7 @@ class ERC721Token(AccessControlContract):   # NFT
         owner = self.owners[token_id]
         if sender != owner and self.token_approvals.get(token_id, None) != sender and \
                 sender not in self.operator_approvals.get(owner, []):
-            raise RevertError("ERC721: transfer caller is not owner nor approved")
+            raise RevertError("ERC721: caller is not token owner or approved")
         # TODO: if `to` is contract, call onERC721Received
         return self._transfer(from_, to, token_id)
 

ethproto/w3wrappers.py

@@ -1,15 +1,27 @@
 import os
-import json
-from .contracts import RevertError
-from .wrappers import (
-    ETHCall, AddressBook, MAXUINT256, ETHWrapper, SKIP_PROXY, register_provider, BaseProvider
-)
+from collections import defaultdict
+from typing import Iterator, List, Union
+
 from environs import Env
 from eth_account.account import Account, LocalAccount
 from eth_account.signers.base import BaseAccount
-from web3.exceptions import ExtraDataLengthError
+from eth_utils.abi import event_abi_to_log_topic
+from hexbytes import HexBytes
+from web3.contract import Contract
+from web3.exceptions import ContractLogicError, ExtraDataLengthError
 from web3.middleware import geth_poa_middleware
-from eth_event import get_topic_map, decode_logs
+
+from .build_artifacts import ArtifactLibrary
+from .contracts import RevertError
+from .wrappers import (
+    MAXUINT256,
+    SKIP_PROXY,
+    AddressBook,
+    BaseProvider,
+    ETHCall,
+    ETHWrapper,
+    register_provider,
+)
 
 env = Env()
 
@@ -20,17 +32,21 @@ W3_ADDRESS_BOOK_CREATE_UNKNOWN = env.str("W3_ADDRESS_BOOK_CREATE_UNKNOWN", "")
 W3_POA = env.str("W3_POA", "auto")
 
 
+# TODO: This should probably be part of the AddressBook
+_contract_map = {}  # Address -> Contract
+
+
 class W3TimeControl:
     def __init__(self, w3):
         self.w3 = w3
 
     def fast_forward(self, secs):
-        self.w3.provider.make_request("evm_increaseTime", [secs])
-        # Not tested!
+        """Mines a new block whose timestamp is secs after the latest block's timestamp."""
+        self.w3.provider.make_request("evm_mine", [self.now + secs])
 
     @property
     def now(self):
-        return self.w3.get_block("latest").timestamp
+        return self.w3.eth.get_block("latest").timestamp
 
 
 def register_w3_provider(provider_key="w3", tester=None, provider_kwargs={}):
@@ -42,6 +58,7 @@ def register_w3_provider(provider_key="w3", tester=None, provider_kwargs={}):
 
     if tester:
         from web3 import Web3
+
         w3 = Web3(Web3.EthereumTesterProvider())
     else:
         from web3.auto import w3
@@ -80,15 +97,19 @@ def transact(provider, function, tx_kwargs):
         else:  # it's a string, I try to get the PK from the environment
             from_ = provider.address_book.get_signer_account(from_)
             tx_kwargs["from"] = from_.address
-        tx = function.buildTransaction(
-            {**tx_kwargs, **{"nonce": provider.w3.eth.get_transaction_count(from_.address)}}
+        tx = function.build_transaction(
+            {
+                **tx_kwargs,
+                **{"nonce": provider.w3.eth.get_transaction_count(from_.address)},
+            }
         )
         signed_tx = from_.sign_transaction(tx)
         tx_hash = provider.w3.eth.send_raw_transaction(signed_tx.rawTransaction)
     elif W3_TRANSACT_MODE == "defender-async":
         from .defender_relay import send_transaction
+
         tx_kwargs = {**provider.tx_kwargs, **tx_kwargs}
-        tx = function.buildTransaction(tx_kwargs)
+        tx = function.build_transaction(tx_kwargs)
         return send_transaction(tx)
 
     return provider.w3.eth.wait_for_transaction_receipt(tx_hash)
@@ -108,11 +129,11 @@ class W3AddressBook(AddressBook):
         return self._eth_accounts
 
     def get_account(self, name):
-        if isinstance(name, (Account, LocalAccount)):
+        if isinstance(name, BaseAccount):
             return name
         if name is None:
             return self.ZERO
-        if type(name) == str and name.startswith("0x"):
+        if isinstance(name, str) and name.startswith("0x"):
             return name
         if name not in self.name_to_address:
             self.last_account_used += 1
@@ -120,10 +141,15 @@ class W3AddressBook(AddressBook):
                 self.name_to_address[name] = self.eth_accounts[self.last_account_used]
             except IndexError:
                 self.name_to_address[name] = self.w3.eth.account.create().address
+                # TODO: This branch only generates a random account and discards the private key. Unlike the accounts in
+                # self.eth_accounts this one is not unlocked on the node. Something like this is necessary for this to
+                # be useful (and consistent with other branches):
+                # self.provider.register_account(address, private_key)
+
         return self.name_to_address[name]
 
     def get_name(self, account_or_address):
-        if isinstance(account_or_address, (LocalAccount, )):
+        if isinstance(account_or_address, (LocalAccount,)):
             account_or_address = account_or_address.address
 
         for name, addr in self.name_to_address.items():
@@ -151,7 +177,7 @@ class W3EnvAddressBook(AddressBook):
                 continue
             if k.endswith("_ADDR"):
                 continue  # Addresses linked to names
-            addr = k[len(env_prefix):]
+            addr = k[len(env_prefix) :]
             if addr.startswith("0x"):
                 account = w3.account.from_key(value)
                 assert account.address == addr
@@ -183,7 +209,7 @@ class W3EnvAddressBook(AddressBook):
         raise RuntimeError(f"No account found for name {name}")
 
     def get_name(self, account_or_address):
-        if isinstance(account_or_address, (LocalAccount, )):
+        if isinstance(account_or_address, (LocalAccount,)):
             account_or_address = account_or_address.address
 
         for name, addr in self.name_to_address.items():
@@ -205,25 +231,105 @@ class ReceiptWrapper:
     @property
     def events(self):
         if not hasattr(self, "_events"):
-            topic_map = get_topic_map(self._contract.abi)
-            logs = decode_logs(self._receipt.logs, topic_map, allow_undecoded=True)
-            evts = {}
-            for evt in logs:
-                evt_name = evt["name"]
-                evt_params = dict((d["name"], d["value"]) for d in evt["data"])
-                if evt_name not in evts:
-                    evts[evt_name] = evt_params
-                elif type(evts[evt_name]) == dict:
-                    evts[evt_name] = [evts[evt_name], evt_params]  # start a list
-                else:  # it's already a list
-                    evts[evt_name].append(evt_params)
-            self._events = evts
+            # Lookup the events in all known contracts
+            addresses = [log.address for log in self._receipt.logs]
+            contracts = {addr: _contract_map[addr] for addr in addresses if addr in _contract_map}
+            topic_map = {
+                HexBytes(event_abi_to_log_topic(event().abi)): event()
+                for contract in contracts.values()
+                for event in contract.events
+            }
+
+            parsed_logs = []
+            for log in self._receipt.logs:
+                for topic in log.topics:
+                    if topic in topic_map:
+                        parsed_logs += topic_map[topic].process_receipt(self._receipt)
+
+            evts = defaultdict(list)
+            for evt in parsed_logs:
+                evt_name = evt.event
+                evt_params = evt.args
+                evts[evt_name].append(evt_params)
+            self._events = {k: EventItem(k, v) for k, v in evts.items()}
         return self._events
 
     def __getattr__(self, attr_name):
         return getattr(self._receipt, attr_name)
 
 
+class EventItem:
+    """
+    Dict/list hybrid container, represents one or more events with the same name
+    that were fired in a transaction.
+
+    Inspired on eth-brownies brownie.network.event._EventItem class
+    """
+
+    def __init__(self, name: str, events: List) -> None:
+        self.name = name
+        self._events = events
+
+    def __getitem__(self, key: Union[int, str]) -> List:
+        """if key is int: returns the n'th event that was fired with this name
+        if key is str: returns the value of data field 'key' from the 1st event
+        within the container"""
+        if not isinstance(key, (int, str)):
+            raise TypeError(f"Invalid key type '{type(key)}' - can only use strings or integers")
+        if isinstance(key, int):
+            try:
+                return self._events[key]
+            except IndexError:
+                raise IndexError(
+                    f"Index {key} out of range - only {len(self._ordered)} '{self.name}' events fired"
+                )
+        if key in self._events[0]:
+            return self._events[0][key]
+        if f"{key} (indexed)" in self._events[0]:
+            return self._events[0][f"{key} (indexed)"]
+        valid_keys = ", ".join(self.keys())
+        raise KeyError(f"Unknown key '{key}' - the '{self.name}' event includes these keys: {valid_keys}")
+
+    def __contains__(self, name: str) -> bool:
+        """returns True if this event contains a value with the given name."""
+        return name in self._events[0]
+
+    def __len__(self) -> int:
+        """returns the number of events held in this container."""
+        return len(self._events)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        if len(self._events) == 1:
+            return str(self._events[0])
+        return str([i[0] for i in self._events])
+
+    def __iter__(self) -> Iterator:
+        return iter(self._events)
+
+    def __eq__(self, other: object) -> bool:
+        if len(self._events) == 1:
+            if isinstance(other, (tuple, list)):
+                # sequences compare directly against the event values
+                return self._events[0].values() == other
+            return other == self._events[0]
+        return other == self._events
+
+    def items(self) -> List:
+        """EventItem.items() -> a list object providing a view on EventItem[0]'s items"""
+        return [(i, self[i]) for i in self.keys()]
+
+    def keys(self) -> List:
+        """EventItem.keys() -> a list object providing a view on EventItem[0]'s keys"""
+        return [i.replace(" (indexed)", "") for i in self._events[0].keys()]
+
+    def values(self) -> List:
+        """EventItem.values() -> a list object providing a view on EventItem[0]'s values"""
+        return self._events[0].values()
+
+
 class W3ETHCall(ETHCall):
     @classmethod
     def find_function_abi(cls, contract, eth_method, eth_variant):
@@ -238,11 +344,14 @@ class W3ETHCall(ETHCall):
         function = getattr(wrapper.contract.functions, eth_method)  # TODO: eth_variant
         function_abi = cls.find_function_abi(wrapper.contract, eth_method, eth_variant)
         if function_abi["stateMutability"] in ("pure", "view"):
+
             def eth_function(*args):
                 if args and type(args[-1]) == dict:
                     args = args[:-1]  # remove dict with {from: ...}
                 return function(*args).call()
+
         else:  # Mutable function, need to send and wait transaction
+
             def eth_function(*args):
                 if args and type(args[-1]) == dict:
                     transact_args = args[-1]
@@ -255,12 +364,16 @@ class W3ETHCall(ETHCall):
 
     def normalize_receipt(self, wrapper, receipt):
         if W3_TRANSACT_MODE == "defender-async":
-            return receipt  # Don't do anything because the receipt it's just a dict of not-yet-mined tx
+            return receipt  # Don't do anything because the receipt is just a dict of not-yet-mined tx
         return ReceiptWrapper(receipt, wrapper.contract)
 
     def _handle_exception(self, err):
-        if str(err).startswith("execution reverted: "):
-            raise RevertError(str(err)[len("execution reverted: "):])
+        if isinstance(err, ContractLogicError):
+            raise RevertError(
+                err.message[len("execution reverted: ") :]
+                if err.message and err.message.startswith("execution reverted: ")
+                else err.message
+            )
         super()._handle_exception(err)
 
     @classmethod
@@ -268,16 +381,14 @@ class W3ETHCall(ETHCall):
         if value_type.startswith("(") and value_type.endswith(")"):
             # It's a tuple / struct
             value_types = [t.strip() for t in value_type.split(",")]
-            return tuple(
-                cls.parse(wrapper, vt, value[i]) for i, vt in enumerate(value_types)
-            )
+            return tuple(cls.parse(wrapper, vt, value[i]) for i, vt in enumerate(value_types))
         if value_type == "address":
-            if isinstance(value, (LocalAccount, Account)):
-                return value
-#            elif isinstance(value, (Contract, ProjectContract)):
-#                return value.address
+            if isinstance(value, BaseAccount):
+                return value.address
             elif isinstance(value, ETHWrapper):
                 return value.contract.address
+            elif isinstance(value, Contract):
+                return value.address
             elif isinstance(value, str) and value.startswith("0x"):
                 return value
             return wrapper.provider.address_book.get_account(value)
@@ -299,30 +410,19 @@ class W3Provider(BaseProvider):
 
     def __init__(self, w3, address_book=None, contracts_path=None, tx_kwargs=None):
         self.w3 = w3
-        self.contracts_path = contracts_path or CONTRACT_JSON_PATH
-        self.contract_def_cache = {}
+        self.artifact_library = ArtifactLibrary(
+            *(contracts_path if contracts_path is not None else CONTRACT_JSON_PATH)
+        )
         self.address_book = address_book or W3AddressBook(w3)
         self.time_control = W3TimeControl(w3)
         self.tx_kwargs = tx_kwargs or {}
 
     def get_contract_def(self, eth_contract):
-        if eth_contract not in self.contract_def_cache:
-            json_file = None
-            for contract_path in self.contracts_path:
-                for sub_path, _, files in os.walk(contract_path):
-                    if f"{eth_contract}.json" in files:
-                        json_file = os.path.join(sub_path, f"{eth_contract}.json")
-                        break
-                if json_file is not None:
-                    break
-            else:
-                raise RuntimeError(f"{eth_contract} JSON definition not found in {self.contracts_path}")
-            self.contract_def_cache[eth_contract] = json.load(open(json_file))
-        return self.contract_def_cache[eth_contract]
+        return self.artifact_library.get_artifact_by_name(eth_contract)
 
     def get_contract_factory(self, eth_contract):
         contract_def = self.get_contract_def(eth_contract)
-        return self.w3.eth.contract(abi=contract_def["abi"], bytecode=contract_def.get("bytecode", None))
+        return self.w3.eth.contract(abi=contract_def.abi, bytecode=contract_def.bytecode)
 
     def deploy(self, eth_contract, init_params, from_, **kwargs):
         factory = self.get_contract_factory(eth_contract)
@@ -358,49 +458,58 @@ class W3Provider(BaseProvider):
 
     def init_eth_wrapper(self, eth_wrapper, owner, init_params, kwargs):
         eth_wrapper.owner = self.address_book.get_account(owner)
-        assert not eth_wrapper.libraries_required, "Not supported"
 
-        eth_contract = self.get_contract_factory(eth_wrapper.eth_contract)
+        contract_def = self.get_contract_def(eth_wrapper.eth_contract)
+        libraries = {}
+        for lib, _ in contract_def.libraries():
+            if lib not in libraries:
+                library_def = self.get_contract_factory(lib)
+                library = self.construct(library_def)
+                libraries[lib] = library.address
+
+        if libraries:
+            contract_def = contract_def.link(libraries)
+
+        eth_contract = self.w3.eth.contract(abi=contract_def.abi, bytecode=contract_def.bytecode)
+
         if eth_wrapper.proxy_kind is None:
             eth_wrapper.contract = self.construct(eth_contract, init_params, {"from": eth_wrapper.owner})
         elif eth_wrapper.proxy_kind == "uups" and not SKIP_PROXY:
             constructor_params, init_params = init_params
             real_contract = self.construct(eth_contract, constructor_params, {"from": eth_wrapper.owner})
             ERC1967Proxy = self.get_contract_factory("ERC1967Proxy")
-            init_data = real_contract.functions.initialize(
-                *init_params
-            ).build_transaction({**self.tx_kwargs, **{"from": eth_wrapper.owner}})["data"]
+            init_data = eth_contract.encodeABI(fn_name="initialize", args=init_params)
             proxy_contract = self.construct(
                 ERC1967Proxy,
                 (real_contract.address, init_data),
-                {**self.tx_kwargs, **{"from": eth_wrapper.owner}}
-            )
-            eth_wrapper.contract = self.w3.eth.contract(
-                abi=eth_contract.abi,
-                address=proxy_contract.address
+                {**self.tx_kwargs, **{"from": eth_wrapper.owner}},
             )
+            eth_wrapper.contract = self.w3.eth.contract(abi=eth_contract.abi, address=proxy_contract.address)
         elif eth_wrapper.proxy_kind == "uups" and SKIP_PROXY:
             constructor_params, init_params = init_params
-            eth_wrapper.contract = self.construct(eth_contract, constructor_params,
-                                                  {"from": eth_wrapper.owner})
+            eth_wrapper.contract = self.construct(
+                eth_contract, constructor_params, {"from": eth_wrapper.owner}
+            )
             transact(
                 self,
                 eth_wrapper.contract.functions.initialize(*init_params),
-                {"from": eth_wrapper.owner}
+                {"from": eth_wrapper.owner},
             )
 
+        _contract_map[eth_wrapper.contract.address] = eth_wrapper.contract
+
     def construct(self, contract_factory, constructor_args=(), transact_kwargs={}):
         try:
-            receipt = transact(
-                self,
-                contract_factory.constructor(*constructor_args),
-                transact_kwargs
-            )
+            receipt = transact(self, contract_factory.constructor(*constructor_args), transact_kwargs)
         except Exception as err:
             if str(err).startswith("execution reverted: "):
-                raise RevertError(str(err)[len("execution reverted: "):])
+                raise RevertError(str(err)[len("execution reverted: ") :])
             raise
         return self.w3.eth.contract(abi=contract_factory.abi, address=receipt.contractAddress)
 
     def build_contract(self, contract_address, contract_factory, contract_name=None):
         return self.w3.eth.contract(abi=contract_factory.abi, address=contract_address)
+
+    def unlock_account(self, address):
+        """Unlocks an account on the node. Assumes hardhat network API."""
+        self.w3.provider.make_request("hardhat_impersonateAccount", [address])

ethproto/wrappers.py

@@ -1,10 +1,14 @@
 """Base module for wrappers"""
+
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
 from functools import partial
-from .wadray import Wad, Ray, make_integer_float
+
 import requests
 from environs import Env
+from hexbytes import HexBytes
+
+from .wadray import Ray, Wad, make_integer_float
 
 env = Env()
 
@@ -43,10 +47,8 @@ def get_provider(provider_key=None):
 def auto_register_provider(provider_key):
     if provider_key == "w3":
         from .w3wrappers import register_w3_provider
+
         register_w3_provider()
-    elif provider_key == "brownie":
-        from .brwrappers import BrownieProvider
-        register_provider("brownie", BrownieProvider())
     else:
         raise RuntimeError(f"Unknown provider {provider_key}")
 
@@ -57,8 +59,16 @@ def register_provider(provider_key, provider):
 
 
 class MethodAdapter:
-    def __init__(self, args=(), return_type="", eth_method=None, adapt_args=None, is_property=False,
-                 set_eth_method=None, eth_variant=None):
+    def __init__(
+        self,
+        args=(),
+        return_type="",
+        eth_method=None,
+        adapt_args=None,
+        is_property=False,
+        set_eth_method=None,
+        eth_variant=None,
+    ):
         self.eth_method = eth_method
         self.set_eth_method = set_eth_method
         self.return_type = return_type
@@ -76,8 +86,8 @@ class MethodAdapter:
 
     @staticmethod
     def snake_to_camel(name):
-        components = name.split('_')
-        return components[0] + ''.join(x.title() for x in components[1:])
+        components = name.split("_")
+        return components[0] + "".join(x.title() for x in components[1:])
 
     @property
     def method_name(self):
@@ -85,8 +95,7 @@ class MethodAdapter:
 
     def __get__(self, instance, owner=None):
         eth_call = instance.eth_call(
-            self.eth_method, self.args, self.return_type, self.adapt_args,
-            eth_variant=self.eth_variant
+            self.eth_method, self.args, self.return_type, self.adapt_args, eth_variant=self.eth_variant
         )
         if self.is_property:
             return eth_call(instance)
@@ -95,7 +104,7 @@ class MethodAdapter:
     def __set__(self, instance, value):
         if not self.is_property:
             raise NotImplementedError()
-        eth_call = instance.eth_call(self.set_eth_method, (("new_value", self.return_type), ))
+        eth_call = instance.eth_call(self.set_eth_method, (("new_value", self.return_type),))
         return eth_call(instance, value)
 
 
@@ -147,7 +156,7 @@ class ETHCall(ABC):
 
     def __call__(self, wrapper, *args, **kwargs):
         call_args = []
-        msg_args = {}
+        msg_args = wrapper.provider.tx_kwargs.copy()
 
         if self.adapt_args:
             args, kwargs = self.adapt_args(args, kwargs)
@@ -203,22 +212,26 @@ class ETHCall(ABC):
         return call_args, msg_args
 
     @classmethod
-    def _parse_keccak256(cls, value):
-        from Crypto.Hash import keccak  # To avoid import of wrappers breaks if keccak not installed
-        if value.startswith("0x"):
+    def _parse_keccak256(cls, value) -> HexBytes:
+        from Crypto.Hash import (
+            keccak,  # To avoid import of wrappers breaks if keccak not installed
+        )
+
+        if isinstance(value, HexBytes):
             return value
+
+        if value.startswith("0x"):
+            return HexBytes(value)
         k = keccak.new(digest_bits=256)
         k.update(value.encode("utf-8"))
-        return k.hexdigest()
+        return HexBytes(k.hexdigest())
 
     @classmethod
     def unparse(cls, wrapper, value_type, value):
         if value_type.startswith("(") and value_type.endswith(")"):
             # It's a tuple / struct
             value_types = [t.strip() for t in value_type.strip("()").split(",")]
-            return tuple(
-                cls.unparse(wrapper, vt, value[i]) for i, vt in enumerate(value_types)
-            )
+            return tuple(cls.unparse(wrapper, vt, value[i]) for i, vt in enumerate(value_types))
         if value_type == "amount":
             return AMOUNT_CLASS(value)
         if value_type == "ray":
@@ -240,6 +253,8 @@ class ETHCall(ABC):
 
 
 class BaseProvider(ABC):
+    tx_kwargs = {}
+
     @abstractmethod
     def get_contract_factory(self, eth_contract):
         raise NotImplementedError()
@@ -259,8 +274,9 @@ class BaseProvider(ABC):
             return 0
         address = self.get_contract_address(eth_wrapper)
         url = (
-            etherscan_url + f"&module=account&action=txlist&address={address}&startblock=0&" +
-            "endblock=99999999&page=1&offset=10&sort=asc"
+            etherscan_url
+            + f"&module=account&action=txlist&address={address}&startblock=0&"
+            + "endblock=99999999&page=1&offset=10&sort=asc"
         )
         resp = requests.get(url)
         resp.raise_for_status()
@@ -305,9 +321,9 @@ class ETHWrapper:
         else:
             if self.constructor_args:
                 constructor_params, transaction_kwargs = self.eth_call.parse_args(
-                    self, self.constructor_args, *init_params[:len(self.constructor_args)], **kwargs
+                    self, self.constructor_args, *init_params[: len(self.constructor_args)], **kwargs
                 )
-                init_params = init_params[len(self.constructor_args):]
+                init_params = init_params[len(self.constructor_args) :]
                 if transaction_kwargs:
                     kwargs.update(transaction_kwargs)
             else:
@@ -357,6 +373,31 @@ class ETHWrapper:
         obj._auto_from = obj.owner
         return obj
 
+    @classmethod
+    def build_from_def(cls, contract_def, extra_properties=None):
+        extra_properties = extra_properties or {}
+        attributes = {}
+        for item in contract_def.abi:
+            if item["type"] == "constructor":
+                attributes["constructor_args"] = tuple((arg["name"], arg["type"]) for arg in item["inputs"])
+            elif item["type"] == "function":
+                attributes[item["name"]] = MethodAdapter(
+                    args=tuple((arg["name"], arg["type"]) for arg in item["inputs"]),
+                    return_type=item["outputs"][0]["type"] if item["outputs"] else "",
+                    eth_method=item["name"],
+                    eth_variant=item["inputs"],
+                )
+        wrapper_class = type(
+            contract_def.contract_name,
+            (cls,),
+            {
+                "eth_contract": contract_def.contract_name,
+                **attributes,
+                **extra_properties,
+            },
+        )
+        return wrapper_class
+
     @property
     def contract_id(self):
         return self.contract.address
@@ -371,8 +412,8 @@ class ETHWrapper:
     revoke_role = MethodAdapter((("role", "keccak256"), ("user", "address")))
     renounce_role = MethodAdapter((("role", "keccak256"), ("user", "address")))
     has_role = MethodAdapter((("role", "keccak256"), ("user", "address")), "bool")
-    get_role_admin = MethodAdapter((("role", "keccak256"), ), "address")
-    get_role_admin = MethodAdapter((("role", "keccak256"), ), "bytes32")
+    get_role_admin = MethodAdapter((("role", "keccak256"),), "address")
+    get_role_admin = MethodAdapter((("role", "keccak256"),), "bytes32")
 
     @contextmanager
     def as_(self, user):
@@ -397,14 +438,15 @@ class IERC20(ETHWrapper):
     symbol = MethodAdapter((), "string", is_property=True)
     decimals = MethodAdapter((), "int", is_property=True)
     total_supply = MethodAdapter((), "amount")
-    balance_of = MethodAdapter((("account", "address"), ), "amount")
-    transfer = MethodAdapter((
-        ("sender", "msg.sender"), ("recipient", "address"), ("amount", "amount")
-    ), "receipt")
+    balance_of = MethodAdapter((("account", "address"),), "amount")
+    transfer = MethodAdapter(
+        (("sender", "msg.sender"), ("recipient", "address"), ("amount", "amount")), "receipt"
+    )
 
     allowance = MethodAdapter((("owner", "address"), ("spender", "address")), "amount")
-    approve = MethodAdapter((("owner", "msg.sender"), ("spender", "address"), ("amount", "amount")),
-                            "receipt")
+    approve = MethodAdapter(
+        (("owner", "msg.sender"), ("spender", "address"), ("amount", "amount")), "receipt"
+    )
     increase_allowance = MethodAdapter(
         (("owner", "msg.sender"), ("spender", "address"), ("amount", "amount"))
     )
@@ -412,9 +454,10 @@ class IERC20(ETHWrapper):
         (("owner", "msg.sender"), ("spender", "address"), ("amount", "amount"))
     )
 
-    transfer_from = MethodAdapter((
-        ("spender", "msg.sender"), ("sender", "address"), ("recipient", "address"), ("amount", "amount")
-    ), "receipt")
+    transfer_from = MethodAdapter(
+        (("spender", "msg.sender"), ("sender", "address"), ("recipient", "address"), ("amount", "amount")),
+        "receipt",
+    )
 
 
 class IERC721(ETHWrapper):
@@ -423,19 +466,21 @@ class IERC721(ETHWrapper):
     name = MethodAdapter((), "string", is_property=True)
     symbol = MethodAdapter((), "string", is_property=True)
     total_supply = MethodAdapter((), "int")
-    balance_of = MethodAdapter((("account", "address"), ), "int")
-    owner_of = MethodAdapter((("token_id", "int"), ), "address")
-    approve = MethodAdapter((
-        ("sender", "msg.sender"), ("spender", "address"), ("token_id", "int")
-    ), "receipt")
-    get_approved = MethodAdapter((("token_id", "int"), ), "address")
-    set_approval_for_all = MethodAdapter((
-        ("sender", "msg.sender"), ("operator", "address"), ("approved", "bool")
-    ))
+    balance_of = MethodAdapter((("account", "address"),), "int")
+    owner_of = MethodAdapter((("token_id", "int"),), "address")
+    approve = MethodAdapter(
+        (("sender", "msg.sender"), ("spender", "address"), ("token_id", "int")), "receipt"
+    )
+    get_approved = MethodAdapter((("token_id", "int"),), "address")
+    set_approval_for_all = MethodAdapter(
+        (("sender", "msg.sender"), ("operator", "address"), ("approved", "bool"))
+    )
     is_approved_for_all = MethodAdapter((("owner", "address"), ("operator", "address")), "bool")
-    transfer_from = MethodAdapter((
-        ("spender", "msg.sender"), ("from", "address"), ("to", "address"), ("token_id", "int")
-    ), "receipt")
-    safe_transfer_from = MethodAdapter((
-        ("spender", "msg.sender"), ("from", "address"), ("to", "address"), ("token_id", "int")
-    ), "receipt", eth_variant="address, address, uint256")
+    transfer_from = MethodAdapter(
+        (("spender", "msg.sender"), ("from", "address"), ("to", "address"), ("token_id", "int")), "receipt"
+    )
+    safe_transfer_from = MethodAdapter(
+        (("spender", "msg.sender"), ("from", "address"), ("to", "address"), ("token_id", "int")),
+        "receipt",
+        eth_variant="address, address, uint256",
+    )

eth_prototype-0.7.5.dist-info/RECORD

@@ -1,13 +0,0 @@
-ethproto/__init__.py,sha256=YWkAFysBp4tZjLWWB2FFmp5yG23pUYhQvgQW9b3soXs,579
-ethproto/brwrappers.py,sha256=sC6N7kzmly5M2s-ewvambbbA-8NbYJZP_MO_UC7o_Z4,9173
-ethproto/contracts.py,sha256=44oEIyCyX2mH-PftG1ZpQ7aXRPJZy95t1tgL29UsqP4,18685
-ethproto/defender_relay.py,sha256=05A8TfRZwiBhCpo924Pf9CjfKSir2Wvgg1p_asFxJbw,1777
-ethproto/w3wrappers.py,sha256=D8NJPvacZb60c5ukFtJyysmQi9H5y72VBnwMKli5DwA,16810
-ethproto/wadray.py,sha256=JBsu5KcyU9k70bDK03T2IY6qPVFO30WbYPhwrAHdXao,8262
-ethproto/wrappers.py,sha256=hlqmmJOzNo2V4BUpMJ4hVzdLYtIb0IqLMU3Up1o-RPU,16185
-eth_prototype-0.7.5.dist-info/AUTHORS.rst,sha256=Ui-05yYXtDZxna6o1yNcfdm8Jt68UIDQ01osiLxlYlU,95
-eth_prototype-0.7.5.dist-info/LICENSE.txt,sha256=U_Q6_nDYDwZPIuhttHi37hXZ2qU2-HlV2geo9hzHXFw,1087
-eth_prototype-0.7.5.dist-info/METADATA,sha256=wLQ8c-2UPhMC0H87QoW-nfWQC3MEFf6aBp8UFFA68hk,3646
-eth_prototype-0.7.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-eth_prototype-0.7.5.dist-info/top_level.txt,sha256=Dl0X7m6N1hxeo4JpGpSNqWC2gtsN0731g-DL1J0mpjc,9
-eth_prototype-0.7.5.dist-info/RECORD,,

ethproto/brwrappers.py

@@ -1,221 +0,0 @@
-import re
-from .contracts import RevertError
-from .wrappers import ETHCall, AddressBook, MAXUINT256, SKIP_PROXY, ETHWrapper, BaseProvider
-import eth_utils
-from brownie import accounts
-import brownie
-from brownie.network.account import Account, LocalAccount
-from brownie.exceptions import VirtualMachineError
-from brownie.network.state import Chain
-from brownie.network.contract import Contract, ProjectContract
-
-
-class BrownieTimeControl:
-    def __init__(self, chain=None):
-        self.chain = chain or Chain()
-
-    def fast_forward(self, secs):
-        self.chain.sleep(secs)
-        self.chain.mine()
-
-    @property
-    def now(self):
-        if len(self.chain) > 0:
-            return self.chain[-1].timestamp
-        return self.chain.time()
-
-
-class BrownieAddressBook(AddressBook):
-
-    def __init__(self, eth_accounts):
-        self.eth_accounts = eth_accounts  # brownie.network.account.Accounts
-        self.name_to_address = {}
-        self.last_account_used = -1
-
-    def get_account(self, name):
-        if isinstance(name, (Account, LocalAccount)):
-            return name
-        if isinstance(name, (Contract, ProjectContract)):
-            return name
-        if name is None:
-            return self.ZERO
-        if name not in self.name_to_address:
-            self.last_account_used += 1
-            if (len(self.eth_accounts) - 1) > self.last_account_used:
-                self.eth_accounts.add()
-                self.name_to_address[name] = self.eth_accounts[self.last_account_used].address
-        return self.eth_accounts.at(self.name_to_address[name])
-
-    def get_name(self, account_or_address):
-        if isinstance(account_or_address, Account):
-            account_or_address = account_or_address.address
-
-        for name, addr in self.name_to_address.items():
-            if addr == account_or_address:
-                return name
-        return None
-
-
-AddressBook.set_instance(BrownieAddressBook(accounts))
-
-
-def encode_function_data(initializer=None, *args):
-    """Encodes the function call so we can work with an initializer.
-    Args:
-        initializer ([brownie.network.contract.ContractTx], optional):
-        The initializer function we want to call. Example: `box.store`.
-        Defaults to None.
-        args (Any, optional):
-        The arguments to pass to the initializer function
-    Returns:
-        [bytes]: Return the encoded bytes.
-    """
-    if not initializer:
-        return eth_utils.to_bytes(hexstr="0x")
-    else:
-        return initializer.encode_input(*args)
-
-
-class BrownieETHCall(ETHCall):
-    error_match = [
-        re.compile('VM Exception while processing transaction: revert with reason "([^"]+)"')
-    ]
-
-    def _handle_exception(self, err):
-        if isinstance(err, VirtualMachineError) and err.revert_type == "revert":
-            raise RevertError(err.revert_msg)
-        # Tries to match error by regex
-        for err_regex in self.error_match:
-            m = err_regex.match(str(err))
-            if m:
-                raise RevertError(m.group(1))
-        super()._handle_exception(err)
-
-    @classmethod
-    def get_eth_function(cls, wrapper, eth_method, eth_variant=None):
-        if eth_variant:
-            return getattr(wrapper.contract, eth_method)[eth_variant]
-        else:
-            return getattr(wrapper.contract, eth_method)
-
-    @classmethod
-    def get_eth_function_and_mutability(cls, wrapper, eth_method, eth_variant=None):
-        function = cls.get_eth_function(wrapper, eth_method, eth_variant)
-        return function, function.abi["stateMutability"]
-
-    @classmethod
-    def parse(cls, wrapper, value_type, value):
-        if value_type.startswith("(") and value_type.endswith(")"):
-            # It's a tuple / struct
-            value_types = [t.strip() for t in value_type.strip("()").split(",")]
-            return tuple(
-                cls.parse(wrapper, vt, value[i]) for i, vt in enumerate(value_types)
-            )
-        if value_type == "address":
-            if isinstance(value, (LocalAccount, Account)):
-                return value
-            elif isinstance(value, (Contract, ProjectContract)):
-                return value.address
-            elif isinstance(value, ETHWrapper):
-                return value.contract.address
-            elif isinstance(value, str) and value.startswith("0x"):
-                return value
-            return wrapper.provider.address_book.get_account(value)
-        if value_type == "keccak256":
-            return cls._parse_keccak256(value)
-        if value_type == "contract":
-            if isinstance(value, ETHWrapper):
-                return value.contract.address
-            elif value is None:
-                return AddressBook.ZERO
-            raise RuntimeError(f"Invalid contract: {value}")
-        if value_type == "amount" and value is None:
-            return MAXUINT256
-        return value
-
-
-class BrownieProvider(BaseProvider):
-    eth_call = BrownieETHCall
-
-    def __init__(self, time_control=None, address_book=None):
-        self.time_control = time_control or BrownieTimeControl()
-        self.address_book = address_book or BrownieAddressBook(accounts)
-
-    def get_contract_factory(self, eth_contract):
-        ret = getattr(brownie, eth_contract, None)
-        if ret is not None:
-            return ret
-        # Might be a manually loaded project or an interface
-        project = brownie.project.get_loaded_projects()[0]
-        ret = getattr(project, eth_contract, None)
-        if ret is not None:
-            return ret
-        return getattr(project.interface, eth_contract)
-
-    def get_events(self, eth_wrapper, event_name, filter_kwargs={}):
-        """Returns a list of events given a filter, like this:
-
-        >>> provider.get_events(currencywrapper, "Transfer", dict(fromBlock=0))
-        [AttributeDict({
-            'args': AttributeDict(
-                {'from': '0x0000000000000000000000000000000000000000',
-                 'to': '0x56Cd397bAA08F2339F0ae470DEA99D944Ac064bB',
-                 'value': 6000000000000000000000}),
-            'event': 'Transfer',
-            'logIndex': 0,
-            'transactionIndex': 0,
-            'transactionHash': HexBytes(
-                '0x406b2cf8de2f12f4d0958e9f0568dc0919f337ed399f8d8d78ddbc648c01f806'
-                ),
-            'address': '0xf8BedC7458fb8cAbD616B5e90F57c34c392e7168',
-            'blockHash': HexBytes('0x7b23c6ea49759bcee769b1a357dec7f63f03bdb1dd13f1ee19868925954134b3'),
-            'blockNumber': 23
-        })]
-        """
-        w3 = brownie.network.web3
-        w3_contract = w3.eth.contract(abi=eth_wrapper.contract.abi, address=eth_wrapper.contract.address)
-        event = getattr(w3_contract.events, event_name)
-        if "fromBlock" not in filter_kwargs:
-            filter_kwargs["fromBlock"] = self.get_first_block(eth_wrapper)
-        event_filter = event.create_filter(**filter_kwargs)
-        return event_filter.get_all_entries()
-
-    def deploy(self, eth_contract, init_params, from_, **kwargs):
-        factory = self.get_contract_factory(eth_contract)
-        kwargs["from"] = from_
-        return factory.deploy(*init_params, kwargs)
-
-    def init_eth_wrapper(self, eth_wrapper, owner, init_params, kwargs):
-        eth_wrapper.owner = self.address_book.get_account(owner)
-        for library in eth_wrapper.libraries_required:
-            self.get_contract_factory(library).deploy({"from": eth_wrapper.owner})
-        eth_contract = self.get_contract_factory(eth_wrapper.eth_contract)
-        if eth_wrapper.proxy_kind is None:
-            eth_wrapper.contract = eth_contract.deploy(*init_params, {"from": eth_wrapper.owner})
-        elif eth_wrapper.proxy_kind == "uups" and not SKIP_PROXY:
-            constructor_params, init_params = init_params
-            real_contract = eth_contract.deploy(*constructor_params, {"from": eth_wrapper.owner})
-            proxy_factory = self.get_contract_factory("ERC1967Proxy")
-            try:
-                proxy_contract = proxy_factory.deploy(
-                    real_contract,
-                    encode_function_data(getattr(real_contract, "initialize", None), *init_params),
-                    {"from": eth_wrapper.owner}
-                )
-            except VirtualMachineError as err:
-                if err.revert_type == "revert":
-                    raise RevertError(err.revert_msg)
-                raise
-
-            # Replace the proxy contract with the implementation in brownie's state
-            # This makes the gas reports work properly for uups contracts
-            self.get_contract_factory("ERC1967Proxy").remove(proxy_contract)
-            eth_wrapper.contract = eth_contract.at(proxy_contract.address)
-
-        elif eth_wrapper.proxy_kind == "uups" and SKIP_PROXY:
-            constructor_params, init_params = init_params
-            eth_wrapper.contract = eth_contract.deploy(*constructor_params, {"from": eth_wrapper.owner})
-            eth_wrapper.contract.initialize(*init_params, {"from": eth_wrapper.owner})
-
-    def build_contract(self, contract_address, contract_factory, contract_name=None):
-        return Contract.from_abi(contract_name or "Contract", contract_address, contract_factory.abi)