mm-eth 0.5.11__py3-none-any.whl → 0.5.13__py3-none-any.whl

mm_eth/async_rpc.py

@@ -1,4 +1,5 @@
 import json
+from collections.abc import Sequence
 from typing import Any
 
 import websockets
@@ -12,9 +13,9 @@ async def rpc_call(
     *,
     nodes: Nodes,
     method: str,
-    params: list[object],
+    params: Sequence[object],
     id_: int = 1,
-    timeout: int = 10,
+    timeout: float = 10,
     proxies: Proxies = None,
     attempts: int = 1,
 ) -> Result[Any]:
@@ -32,7 +33,7 @@ async def rpc_call(
     return res
 
 
-async def _http_call(node: str, data: dict[str, object], timeout: int, proxy: str | None) -> Result[Any]:
+async def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
     res = await hra(node, method="POST", proxy=proxy, timeout=timeout, params=data, json_params=True)
     if res.is_error():
         return res.to_err_result()
@@ -47,7 +48,7 @@ async def _http_call(node: str, data: dict[str, object], timeout: int, proxy: st
         return res.to_err_result(f"exception: {err}")
 
 
-async def _ws_call(node: str, data: dict[str, object], timeout: int) -> Result[Any]:
+async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result[Any]:
     try:
         async with websockets.connect(node, timeout=timeout) as ws:
             await ws.send(json.dumps(data))

mm_eth/ens.py

@@ -1,7 +1,14 @@
+from ens.utils import normal_name_to_hash
 from mm_crypto_utils import Nodes, Proxies, random_node, random_proxy
 from mm_std import Err, Ok, Result
+from web3 import Web3
 
-from mm_eth.utils import get_async_w3, get_w3
+from mm_eth.async_rpc import rpc_call
+from mm_eth.utils import get_w3
+
+ENS_REGISTRY_ADDRESS: str = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
+FUNC_SELECTOR_RESOLVER: str = "0x0178b8bf"  # resolver(bytes32)
+FUNC_SELECTOR_NAME: str = "0x691f3431"  # name(bytes32)
 
 
 def get_name_with_retries(
@@ -25,27 +32,75 @@ def get_name(rpc_url: str, address: str, timeout: float = 5, proxy: str | None =
             error = e.__class__.__qualname__
         return Err("exception: " + error)
 
+    # async def async_get_name(rpc_url: str, address: str, timeout: float = 5, proxy: str | None = None) -> Result[str | None]:
+    #     w3 = await get_async_w3(rpc_url, timeout=timeout, proxy=proxy)
+    #     try:
+    #         res = await w3.ens.name(w3.to_checksum_address(address))  # type: ignore[union-attr]
+    #         return Ok(res)
+    #     except Exception as e:
+    #         error = str(e)
+    #         if not error:
+    #             error = e.__class__.__qualname__
+    #         return Err("exception: " + error)
+    #     finally:
+    #         await w3.provider.disconnect()
+
+
+async def get_name_async(rpc_url: str, address: str, timeout: float = 5, proxy: str | None = None) -> Result[str | None]:
+    checksum_addr: str = Web3.to_checksum_address(address)
+    reverse_name: str = checksum_addr.lower()[2:] + ".addr.reverse"
+    name_hash_hex: str = normal_name_to_hash(reverse_name).hex()
+
+    resolver_data: str = FUNC_SELECTOR_RESOLVER + name_hash_hex
+
+    resolver_params = [{"to": ENS_REGISTRY_ADDRESS, "data": resolver_data}, "latest"]
+
+    resolver_res: Result[str] = await rpc_call(
+        nodes=rpc_url,
+        method="eth_call",
+        params=resolver_params,
+        timeout=timeout,
+        proxies=proxy,
+        attempts=1,
+    )
+    if not isinstance(resolver_res, Ok) or len(resolver_res.ok) != 66:
+        return Ok(None)
+
+    resolver_address: str = Web3.to_checksum_address("0x" + resolver_res.ok[-40:])
+
+    name_data: str = FUNC_SELECTOR_NAME + name_hash_hex
+    name_params = [{"to": resolver_address, "data": name_data}, "latest"]
+
+    name_res: Result[str] = await rpc_call(
+        nodes=rpc_url,
+        method="eth_call",
+        params=name_params,
+        timeout=timeout,
+        proxies=proxy,
+        attempts=1,
+    )
+
+    if isinstance(name_res, Err):
+        return name_res
+    if name_res.ok == "0x":
+        return Ok(None)
 
-async def async_get_name(rpc_url: str, address: str, timeout: float = 5, proxy: str | None = None) -> Result[str | None]:
-    w3 = await get_async_w3(rpc_url, timeout=timeout, proxy=proxy)
     try:
-        res = await w3.ens.name(w3.to_checksum_address(address))  # type: ignore[union-attr]
-        return Ok(res)
+        hex_data: str = name_res.ok
+        length_hex: str = hex_data[66:130]
+        str_len: int = int(length_hex, 16) * 2
+        name_hex: str = hex_data[130 : 130 + str_len]
+        return Ok(bytes.fromhex(name_hex).decode("utf-8"))
     except Exception as e:
-        error = str(e)
-        if not error:
-            error = e.__class__.__qualname__
-        return Err("exception: " + error)
-    finally:
-        await w3.provider.disconnect()
+        return Err(e)
 
 
-async def async_get_name_with_retries(
+async def get_name_with_retries_async(
     rpc_urls: Nodes, address: str, retries: int, timeout: float = 5, proxies: Proxies = None
 ) -> Result[str | None]:
     res: Result[str | None] = Err("not started yet")
     for _ in range(retries):
-        res = await async_get_name(random_node(rpc_urls), address, timeout=timeout, proxy=random_proxy(proxies))
+        res = await get_name_async(random_node(rpc_urls), address, timeout=timeout, proxy=random_proxy(proxies))
         if res.is_ok():
             return res
     return res

mm_eth/rpc_async.py

@@ -0,0 +1,109 @@
+import json
+import string
+from collections.abc import Sequence
+from typing import Any
+
+import eth_utils
+import websockets
+from mm_std import DataResult, http_request
+
+
+async def rpc_call(
+    node: str,
+    method: str,
+    params: Sequence[object],
+    timeout: float,
+    proxy: str | None,
+    id_: int = 1,
+) -> DataResult[Any]:
+    data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
+    if node.startswith("http"):
+        return await _http_call(node, data, timeout, proxy)
+    return await _ws_call(node, data, timeout)
+
+
+async def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> DataResult[Any]:
+    res = await http_request(node, method="POST", proxy=proxy, timeout=timeout, json=data)
+    if res.is_error():
+        return res.to_data_result_err()
+    try:
+        parsed_body = res.parse_json_body()
+        err = parsed_body.get("error", {}).get("message", "")
+        if err:
+            return res.to_data_result_err(f"service_error: {err}")
+        if "result" in parsed_body:
+            return res.to_data_result_ok(parsed_body["result"])
+        return res.to_data_result_err("unknown_response")
+    except Exception as err:
+        return res.to_data_result_err(f"exception: {err}")
+
+
+async def _ws_call(node: str, data: dict[str, object], timeout: float) -> DataResult[Any]:
+    try:
+        async with websockets.connect(node, timeout=timeout) as ws:
+            await ws.send(json.dumps(data))
+            response = json.loads(await ws.recv())
+
+        err = response.get("error", {}).get("message", "")
+        if err:
+            return DataResult(err=f"service_error: {err}", data=response)
+        if "result" in response:
+            return DataResult(ok=response["result"], data=response)
+        return DataResult(err="unknown_response", data=response)
+    except TimeoutError:
+        return DataResult(err="timeout")
+    except Exception as err:
+        return DataResult(err=f"exception: {err}")
+
+
+async def eth_block_number(node: str, timeout: int = 10, proxy: str | None = None) -> DataResult[int]:
+    return (await rpc_call(node, "eth_blockNumber", [], timeout, proxy)).map(hex_str_to_int)
+
+
+async def eth_get_balance(node: str, address: str, timeout: int = 10, proxy: str | None = None) -> DataResult[int]:
+    return (await rpc_call(node, "eth_getBalance", [address, "latest"], timeout, proxy)).map(hex_str_to_int)
+
+
+async def erc20_balance(
+    node: str,
+    token_address: str,
+    user_address: str,
+    timeout: float = 7.0,
+    proxy: str | None = None,
+) -> DataResult[int]:
+    data = "0x70a08231000000000000000000000000" + user_address[2:]
+    params = [{"to": token_address, "data": data}, "latest"]
+    return (await rpc_call(node, "eth_call", params, timeout, proxy)).map(hex_str_to_int)
+
+
+async def erc20_name(node: str, token_address: str, timeout: float = 7.0, proxy: str | None = None) -> DataResult[str]:
+    params = [{"to": token_address, "data": "0x06fdde03"}, "latest"]
+    return (await rpc_call(node, "eth_call", params, timeout, proxy)).map(_normalize_str)
+
+
+async def erc20_symbol(node: str, token_address: str, timeout: float = 7.0, proxy: str | None = None) -> DataResult[str]:
+    params = [{"to": token_address, "data": "0x95d89b41"}, "latest"]
+    return (await rpc_call(node, "eth_call", params, timeout, proxy)).map(_normalize_str)
+
+
+async def erc20_decimals(node: str, token_address: str, timeout: float = 7.0, proxy: str | None = None) -> DataResult[int]:
+    params = [{"to": token_address, "data": "0x313ce567"}, "latest"]
+    res = await rpc_call(node, "eth_call", params, timeout, proxy)
+    if res.is_err():
+        return res
+    try:
+        if res.unwrap() == "0x":
+            return DataResult(err="no_decimals", data=res.data)
+        value = res.unwrap()
+        result = eth_utils.to_int(hexstr=value[0:66]) if len(value) > 66 else eth_utils.to_int(hexstr=value)
+        return DataResult(ok=result, data=res.data)
+    except Exception as e:
+        return DataResult(err=f"exception: {e}", data=res.data)
+
+
+def hex_str_to_int(value: str) -> int:
+    return int(value, 16)
+
+
+def _normalize_str(value: str) -> str:
+    return "".join(filter(lambda x: x in string.printable, eth_utils.to_text(hexstr=value))).strip()

mm_eth/utils.py

@@ -196,6 +196,8 @@ def get_w3(rpc_url: str, timeout: float | None = None, proxy: str | None = None)
 
 
 async def get_async_w3(rpc_url: str, timeout: float | None = None, proxy: str | None = None) -> AsyncWeb3:
+    # TODO: Don't use async w3. AsyncHTTPProvider uses threads
+    #  check its constructor: self._request_session_manager = HTTPSessionManager()
     request_kwargs: dict[str, object] = {"timeout": timeout}
     if proxy and proxy.startswith("http"):
         request_kwargs["proxy"] = proxy

{mm_eth-0.5.11.dist-info → mm_eth-0.5.13.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-eth
-Version: 0.5.11
+Version: 0.5.13
 Requires-Python: >=3.12
 Requires-Dist: aiohttp-socks~=0.10.1
-Requires-Dist: mm-crypto-utils>=0.2.10
+Requires-Dist: mm-crypto-utils>=0.2.12
+Requires-Dist: mm-std~=0.3.29
 Requires-Dist: typer>=0.15.2
-Requires-Dist: web3~=7.9.0
+Requires-Dist: web3~=7.10.0
 Requires-Dist: websocket-client~=1.8.0

{mm_eth-0.5.11.dist-info → mm_eth-0.5.13.dist-info}/RECORD

@@ -2,18 +2,19 @@ mm_eth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_eth/abi.py,sha256=Qf-QOsR9QexyQM9XWKNeTMkRarIL3XQJbaDbJ8ifMrw,4856
 mm_eth/account.py,sha256=k0MNMatBe0zo1iKZiB_Tq6zyEIo22IncD6ewNUJp3dY,2075
 mm_eth/anvil.py,sha256=98RCfI7dEpxFBTV6UErYvubWVP3n0ctUFn1--4kZ84U,1603
-mm_eth/async_rpc.py,sha256=bQUzb6lgadkxLyc5041qaxe12fvXmUKTJM77dKx1wJE,2934
+mm_eth/async_rpc.py,sha256=zjPcOoC-NTjMxbWu6cRQn-knHEQ75ZO5L-KZoaiwUJ0,2981
 mm_eth/constants.py,sha256=Cy_G-IleBH4gAZ4ok8AGHHlqmdW0ZM7ZldyVpzAfWLs,54
 mm_eth/deploy.py,sha256=SB3ruY808_5UnG8kHR34uVP66P3zOWZu0ImKD7UUv2s,691
-mm_eth/ens.py,sha256=x36ttvVtpwbi6iZ2AuPiOSRxz2WVoVVGLbMun_AmZgg,1918
+mm_eth/ens.py,sha256=lH3TZABYFBiEEtWlyxCqrcYC-nZQsI_1wSCMzBzHPrM,3860
 mm_eth/erc20.py,sha256=LZmTkjmXpN7sUhOtSLiTqb8Ubet9C9q32EQwTS78OqE,7378
 mm_eth/ethernodes.py,sha256=V4VVbC6Nr9jhwT7blxtLugXC5KfXqE8n-kP0VvGHbqo,3070
 mm_eth/json_encoder.py,sha256=S4oD-qfTVztMb4sRpY1puhBQwOBofTyQXWszmdXk4og,433
 mm_eth/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_eth/rpc.py,sha256=k0eHxo_Dp6G0fHQ_rD-QbwOJz5ngC6kxBjl5NEHnyw8,13832
+mm_eth/rpc_async.py,sha256=3AzSSA9zQ_sPtGT4TUDUCorFGnDlmQC4WnmbwmUQETY,4260
 mm_eth/solc.py,sha256=dYRvT8PjZlLDZhNsc_-0790Eug_ZwU2G-iBfIdGj6wQ,1071
 mm_eth/tx.py,sha256=efSoMCoWkenbGdHo1_LX66_Edz1HvED5-J_i3wrHwMw,4051
-mm_eth/utils.py,sha256=bkh4EBaxTYEnrR1s7zQ2hzZCwXw1r-2HmfN-dpTXwRc,8069
+mm_eth/utils.py,sha256=FytG3U6h80mnUaKP8W2mPZ77EuOp4U7pVbPuoKI3wW4,8215
 mm_eth/vault.py,sha256=h8NyiOQh5YFskh1lZA3KyvnJUnxl9769ME2ChplG0CM,1477
 mm_eth/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_eth/cli/calcs.py,sha256=cLFTYNAN-I53tUiSg-zFfVr2afjIZPftDDjHj16FBz0,1068
@@ -42,7 +43,7 @@ mm_eth/cli/cmd/wallet/private_key_cmd.py,sha256=Fv_2OLog1h32pIP7PJITwl_pHdy3BXva
 mm_eth/cli/examples/balances.toml,sha256=i_ALpiEcf8-0TFiUg1cgJhxxfHYeBl9x0b3tnUWjswU,421
 mm_eth/cli/examples/call_contract.toml,sha256=ZQWK-409V_vLIZ2bsRD5RCWPPzShPz2KJTTRQY4YaGw,248
 mm_eth/cli/examples/transfer.toml,sha256=8mWuphDquoSDJw-hb9VJqtonjmv3kJ5Ip8jJ4t5YnfM,1810
-mm_eth-0.5.11.dist-info/METADATA,sha256=w72FUYGmTMgY2Y-6fNSllbRUkoXScJI8UhK097KmBgk,246
-mm_eth-0.5.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_eth-0.5.11.dist-info/entry_points.txt,sha256=aGhpsozl8NIrkuUcX5fSgURCcDhr3ShUdeTSIrJq4oc,46
-mm_eth-0.5.11.dist-info/RECORD,,
+mm_eth-0.5.13.dist-info/METADATA,sha256=AyFH0U7lyIP_seMH_MsCOwQHUsw-85j0jH2eloElwXA,277
+mm_eth-0.5.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_eth-0.5.13.dist-info/entry_points.txt,sha256=aGhpsozl8NIrkuUcX5fSgURCcDhr3ShUdeTSIrJq4oc,46
+mm_eth-0.5.13.dist-info/RECORD,,