fix: changed to using new names in updated web3py versions

ErikBjare · ErikBjare · commit 00a97bd81a0c · 2023-02-24T21:03:45.000+01:00
diff --git a/uniswap/cli.py b/uniswap/cli.py
@@ -28,10 +28,10 @@ def _coerce_to_checksum(addr: str) -> str:
             raise ValueError(
                 "token was not an address, and a shorthand was not found in the token db"
             )
-    if Web3.isChecksumAddress(addr):
+    if Web3.is_checksum_address(addr):
         return addr
     else:
-        return Web3.toChecksumAddress(addr)
+        return Web3.to_checksum_address(addr)
 
 
 @click.group()
diff --git a/uniswap/tokens.py b/uniswap/tokens.py
@@ -5,7 +5,7 @@
 
 
 tokens_mainnet: Dict[str, ChecksumAddress] = {
-    k: Web3.toChecksumAddress(v)
+    k: Web3.to_checksum_address(v)
     for k, v in {
         "ETH": "0x0000000000000000000000000000000000000000",
         "WETH": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
@@ -18,7 +18,7 @@
 }
 
 tokens_rinkeby: Dict[str, ChecksumAddress] = {
-    k: Web3.toChecksumAddress(v)
+    k: Web3.to_checksum_address(v)
     for k, v in {
         "ETH": "0x0000000000000000000000000000000000000000",
         "DAI": "0x2448eE2641d78CC42D7AD76498917359D961A783",
@@ -27,7 +27,7 @@
 }
 
 tokens_arbitrum: Dict[str, ChecksumAddress] = {
-    k: Web3.toChecksumAddress(v)
+    k: Web3.to_checksum_address(v)
     for k, v in {
         "ETH": "0x0000000000000000000000000000000000000000",
         "WETH": "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
diff --git a/uniswap/uniswap.py b/uniswap/uniswap.py
@@ -8,7 +8,8 @@
 from web3 import Web3
 from web3._utils.abi import map_abi_data
 from web3._utils.normalizers import BASE_RETURN_NORMALIZERS
-from web3.contract import Contract, ContractFunction
+from web3.contract import Contract
+from web3.contract.base_contract import BaseContractFunction
 from web3.exceptions import BadFunctionCallOutput, ContractLogicError
 from web3.types import (
     TxParams,
@@ -18,7 +19,6 @@
 )
 from eth_typing.evm import Address, ChecksumAddress
 from hexbytes import HexBytes
-
 from .types import AddressLike
 from .token import ERC20Token
 from .exceptions import InvalidToken, InsufficientBalance
@@ -1435,12 +1435,12 @@ def _deadline(self) -> int:
         return int(time.time()) + 10 * 60
 
     def _build_and_send_tx(
-        self, function: ContractFunction, tx_params: Optional[TxParams] = None
+        self, function: BaseContractFunction, tx_params: Optional[TxParams] = None
     ) -> HexBytes:
         """Build and send a transaction."""
         if not tx_params:
             tx_params = self._get_tx_params()
-        transaction = function.build_transaction(tx_params)
+        transaction = function._build_transaction(tx_params)
 
         if "gas" not in tx_params:
             # `use_estimate_gas` needs to be True for networks like Arbitrum (can't assume 250000 gas),
@@ -1465,7 +1465,9 @@ def _build_and_send_tx(
             logger.debug(f"nonce: {tx_params['nonce']}")
             self.last_nonce = Nonce(tx_params["nonce"] + 1)
 
-    def _get_tx_params(self, value: Wei = Wei(0), gas: Optional[Wei] = None) -> TxParams:
+    def _get_tx_params(
+        self, value: Wei = Wei(0), gas: Optional[Wei] = None
+    ) -> TxParams:
         """Get generic transaction parameters."""
         params: TxParams = {
             "from": _addr_to_str(self.address),
@@ -1569,7 +1571,7 @@ def multicall(
             block_identifier="latest"
         )
         decoded_results = [
-            self.w3.codec.decode_abi(output_types, multicall_result)
+            self.w3.codec.decode(output_types, multicall_result)
             for multicall_result in results
         ]
         normalized_results = [
@@ -1669,7 +1671,7 @@ def create_pool_instance(
         )
         receipt = self.w3.eth.wait_for_transaction_receipt(tx)
 
-        event_logs = self.factory_contract.events.PoolCreated().processReceipt(receipt)
+        event_logs = self.factory_contract.events.PoolCreated().process_receipt(receipt)
         pool_address = event_logs[0]["args"]["pool"]
         pool_instance = _load_contract(
             self.w3, abi_name="uniswap-v3/pool", address=pool_address
@@ -1823,27 +1825,27 @@ def get_raw_price(
 
         if self.version == 2:
             params: Iterable[Union[ChecksumAddress, Optional[int]]] = [
-                self.w3.toChecksumAddress(token_in),
-                self.w3.toChecksumAddress(token_out),
+                self.w3.to_checksum_address(token_in),
+                self.w3.to_checksum_address(token_out),
             ]
             pair_token = self.factory_contract.functions.getPair(*params).call()
             token_in_erc20 = _load_contract_erc20(
-                self.w3, self.w3.toChecksumAddress(token_in)
+                self.w3, self.w3.to_checksum_address(token_in)
             )
             token_in_balance = int(
                 token_in_erc20.functions.balanceOf(
-                    self.w3.toChecksumAddress(pair_token)
+                    self.w3.to_checksum_address(pair_token)
                 ).call()
             )
             token_in_decimals = self.get_token(token_in).decimals
             token_in_balance = token_in_balance / (10**token_in_decimals)
 
             token_out_erc20 = _load_contract_erc20(
-                self.w3, self.w3.toChecksumAddress(token_out)
+                self.w3, self.w3.to_checksum_address(token_out)
             )
             token_out_balance = int(
                 token_out_erc20.functions.balanceOf(
-                    self.w3.toChecksumAddress(pair_token)
+                    self.w3.to_checksum_address(pair_token)
                 ).call()
             )
             token_out_decimals = self.get_token(token_out).decimals
@@ -1852,15 +1854,15 @@ def get_raw_price(
             raw_price = token_out_balance / token_in_balance
         else:
             params = [
-                self.w3.toChecksumAddress(token_in),
-                self.w3.toChecksumAddress(token_out),
+                self.w3.to_checksum_address(token_in),
+                self.w3.to_checksum_address(token_out),
                 fee,
             ]
             pool_address = self.factory_contract.functions.getPool(*params).call()
             pool_contract = _load_contract(
                 self.w3, abi_name="uniswap-v3/pool", address=pool_address
             )
-            t0 = pool_contract.functions.token0().call()
+            # t0 = pool_contract.functions.token0().call()
             t1 = pool_contract.functions.token1().call()
             if t1.lower() == token_in.lower():
                 den0 = self.get_token(token_in).decimals
@@ -1953,7 +1955,9 @@ def _token_address_from_exchange(self, exchange_addr: AddressLike) -> Address:
     @functools.lru_cache()
     @supports([1])
     def _exchange_contract(
-        self, token_addr: Optional[AddressLike] = None, ex_addr: Optional[AddressLike] = None
+        self,
+        token_addr: Optional[AddressLike] = None,
+        ex_addr: Optional[AddressLike] = None,
     ) -> Contract:
         if not ex_addr and token_addr:
             ex_addr = self._exchange_address_from_token(token_addr)
diff --git a/uniswap/util.py b/uniswap/util.py
@@ -4,7 +4,7 @@
 import functools
 import lru
 
-from typing import Any, Generator, Sequence, Union, List, Tuple, Type, Dict, cast
+from typing import Any, Generator, List, Sequence, Tuple, Union
 
 from web3 import Web3
 from web3.exceptions import NameNotFound
@@ -18,7 +18,7 @@
 
 def _get_eth_simple_cache_middleware() -> Middleware:
     return construct_simple_cache_middleware(
-        cache_class=cast(Type[Dict[Any, Any]], functools.partial(lru.LRU, 256)),
+        cache=functools.partial(lru.LRU, 256),  # type: ignore
         rpc_whitelist=SIMPLE_CACHE_RPC_WHITELIST,
     )
 
@@ -37,10 +37,10 @@ def _str_to_addr(s: Union[AddressLike, str]) -> Address:
 def _addr_to_str(a: AddressLike) -> str:
     if isinstance(a, bytes):
         # Address or ChecksumAddress
-        addr: str = Web3.toChecksumAddress("0x" + bytes(a).hex())
+        addr: str = Web3.to_checksum_address("0x" + bytes(a).hex())
         return addr
     elif isinstance(a, str) and a.startswith("0x"):
-        addr = Web3.toChecksumAddress(a)
+        addr = Web3.to_checksum_address(a)
         return addr
 
     raise NameNotFound(a)
@@ -63,7 +63,7 @@ def _load_abi(name: str) -> str:
 
 @functools.lru_cache()
 def _load_contract(w3: Web3, abi_name: str, address: AddressLike) -> Contract:
-    address = Web3.toChecksumAddress(address)
+    address = Web3.to_checksum_address(address)
     return w3.eth.contract(address=address, abi=_load_abi(abi_name))  # type: ignore
 
 
