mm-eth 0.5.16__py3-none-any.whl → 0.6.0__py3-none-any.whl

mm_eth/cli/validators.py

@@ -1,11 +1,18 @@
 from collections.abc import Callable
 
+import eth_utils
 from mm_crypto_utils import AddressToPrivate, ConfigValidators, Transfer
 
-from mm_eth.account import address_from_private, is_address
-from mm_eth.constants import SUFFIX_DECIMALS
+from mm_eth import account
 
-from . import calcs
+SUFFIX_DECIMALS = {"eth": 18, "gwei": 9, "ether": 18}
+
+
+def address_from_private(private_key: str) -> str:
+    res = account.private_to_address(private_key)
+    if res.is_err():
+        raise ValueError("invalid private key")
+    return res.unwrap().lower()
 
 
 class Validators(ConfigValidators):
@@ -23,7 +30,7 @@ class Validators(ConfigValidators):
 
     @staticmethod
     def eth_transfers() -> Callable[[str], list[Transfer]]:
-        return ConfigValidators.transfers(is_address, to_lower=True)
+        return ConfigValidators.transfers(is_address=eth_utils.is_address, to_lower=True)
 
     @staticmethod
     def eth_private_keys() -> Callable[[str], AddressToPrivate]:
@@ -31,18 +38,8 @@ class Validators(ConfigValidators):
 
     @staticmethod
     def eth_address() -> Callable[[str], str]:
-        return ConfigValidators.address(is_address, to_lower=True)
+        return ConfigValidators.address(eth_utils.is_address, to_lower=True)
 
     @staticmethod
     def eth_addresses(unique: bool) -> Callable[[str], list[str]]:
-        return ConfigValidators.addresses(unique, to_lower=True, is_address=is_address)
-
-
-def is_valid_calc_function_args(value: str | None) -> bool:
-    if value is None:
-        return True
-    try:
-        calcs.calc_function_args(value)
-        return True  # noqa: TRY300
-    except ValueError:
-        return False
+        return ConfigValidators.addresses(unique, to_lower=True, is_address=eth_utils.is_address)

mm_eth/converters.py

@@ -0,0 +1,56 @@
+from decimal import Decimal, localcontext
+from typing import cast
+
+import eth_utils
+from web3.types import Wei
+
+
+def to_wei(value: str | int | Decimal, decimals: int | None = None) -> Wei:
+    if isinstance(value, int):
+        return Wei(value)
+    if isinstance(value, Decimal):
+        if value != value.to_integral_value():
+            raise ValueError(f"value must be integral number: {value}")
+        return Wei(int(value))
+    if isinstance(value, str):
+        value = value.lower().replace(" ", "").strip()
+        if value.endswith("gwei"):
+            value = value.replace("gwei", "")
+            return Wei(int(Decimal(value) * 1000000000))
+        if value.endswith("ether"):
+            value = value.replace("ether", "")
+            return Wei(int(Decimal(value) * 1000000000000000000))
+        if value.endswith("eth"):
+            value = value.replace("eth", "")
+            return Wei(int(Decimal(value) * 1000000000000000000))
+        if value.endswith("t"):
+            if decimals is None:
+                raise ValueError("t without decimals")
+            value = value.removesuffix("t")
+            return Wei(int(Decimal(value) * 10**decimals))
+        if value.isdigit():
+            return Wei(int(value))
+        raise ValueError("wrong value " + value)
+
+    raise ValueError(f"value has a wrong type: {type(value)}")
+
+
+def from_wei(value: int, unit: str, round_ndigits: int | None = None, decimals: int | None = None) -> Decimal:
+    if value == 0:
+        return Decimal(0)
+
+    is_negative = value < 0
+    if unit.lower() == "eth":
+        unit = "ether"
+
+    if unit.lower() == "t":
+        if decimals is None:
+            raise ValueError("t without decimals")
+        with localcontext() as ctx:
+            ctx.prec = 999
+            res = Decimal(value=abs(value), context=ctx) / Decimal(10**decimals)
+    else:
+        res = cast(Decimal, eth_utils.from_wei(abs(value), unit))
+    if round_ndigits is not None:
+        res = round(res, ndigits=round_ndigits)
+    return -1 * res if is_negative else res

mm_eth/erc20.py

@@ -1,203 +1,18 @@
-from __future__ import annotations
-
-import string
-from collections.abc import Sequence
-from dataclasses import dataclass
-
 import eth_abi
 import eth_utils
 from eth_typing import HexStr
-from eth_utils import to_checksum_address, to_hex
-from mm_crypto_utils import Nodes, Proxies
-from mm_std import Err, Ok, Result
 
-from mm_eth import async_rpc, rpc
-from mm_eth.rpc import Log
-from mm_eth.tx import SignedTx, sign_legacy_tx, sign_tx
-from mm_eth.utils import hex_str_to_int, hex_to_bytes, log_topic_to_address
+from mm_eth import tx
+from mm_eth.tx import SignedTx
 
 TRANSFER_METHOD = "0xa9059cbb"
 TRANSFER_TOPIC = HexStr("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef")
 
 
-USDT_MAINNET_ADDRESS = "0xdac17f958d2ee523a2206206994597c13d831ec7"
-
-
-@dataclass
-class TransferEventLog:
-    token_address: str
-    from_address: str
-    to_address: str
-    value: int
-    tx_hash: str
-    block_number: int
-    log_index: int
-
-    @staticmethod
-    def from_log(log: Log) -> Result[TransferEventLog]:
-        try:
-            return Ok(
-                TransferEventLog(
-                    token_address=log.address,
-                    from_address=log_topic_to_address(log.topics[1]),
-                    to_address=log_topic_to_address(log.topics[2]),
-                    value=int(log.data, 16),
-                    tx_hash=log.transaction_hash,
-                    block_number=log.block_number,
-                    log_index=log.log_index,
-                ),
-            )
-        except Exception as err:
-            return Err(err)
-
-
-def get_balance(
-    rpc_urls: Nodes,
-    token_address: str,
-    user_address: str,
-    timeout: int = 10,
-    proxies: Proxies = None,
-    attempts: int = 1,
-) -> Result[int]:
-    data = "0x70a08231000000000000000000000000" + user_address[2:]
-    return rpc.rpc_call(
-        nodes=rpc_urls,
-        method="eth_call",
-        params=[{"to": token_address, "data": data}, "latest"],
-        timeout=timeout,
-        proxies=proxies,
-        attempts=attempts,
-    ).and_then(hex_str_to_int)
-
-
-async def async_get_balance(
-    rpc_urls: Nodes,
-    token_address: str,
-    user_address: str,
-    timeout: int = 10,
-    proxies: Proxies = None,
-    attempts: int = 1,
-) -> Result[int]:
-    data = "0x70a08231000000000000000000000000" + user_address[2:]
-    return (
-        await async_rpc.rpc_call(
-            nodes=rpc_urls,
-            method="eth_call",
-            params=[{"to": token_address, "data": data}, "latest"],
-            timeout=timeout,
-            proxies=proxies,
-            attempts=attempts,
-        )
-    ).and_then(hex_str_to_int)
-
-
-def get_name(rpc_urls: Nodes, address: str, timeout: int = 10, proxies: Proxies = None, attempts: int = 1) -> Result[str]:
-    return rpc.rpc_call(
-        nodes=rpc_urls,
-        method="eth_call",
-        params=[{"to": address, "data": "0x06fdde03"}, "latest"],
-        timeout=timeout,
-        proxies=proxies,
-        attempts=attempts,
-    ).and_then(_normalize_str)
-
-
-def get_symbol(rpc_urls: Nodes, address: str, timeout: int = 10, proxies: Proxies = None, attempts: int = 1) -> Result[str]:
-    return rpc.rpc_call(
-        nodes=rpc_urls,
-        method="eth_call",
-        params=[{"to": address, "data": "0x95d89b41"}, "latest"],
-        timeout=timeout,
-        proxies=proxies,
-        attempts=attempts,
-    ).and_then(_normalize_str)
-
-
-def get_decimals(rpc_urls: Nodes, address: str, timeout: int = 10, proxies: Proxies = None, attempts: int = 1) -> Result[int]:
-    res = rpc.rpc_call(
-        nodes=rpc_urls,
-        method="eth_call",
-        params=[{"to": address, "data": "0x313ce567"}, "latest"],
-        timeout=timeout,
-        proxies=proxies,
-        attempts=attempts,
-    )
-    if isinstance(res, Err):
-        return res
-
-    try:
-        if res.ok == "0x":
-            return Err("no_decimals", data=res.data)
-
-        result = eth_utils.to_int(hexstr=res.ok[0:66]) if len(res.ok) > 66 else eth_utils.to_int(hexstr=res.ok)
-        return Ok(result, data=res.data)
-
-    except Exception as e:
-        return Err(f"exception: {e}", data=res.data)
-
-
 def encode_transfer_input_data(recipient: str, value: int) -> str:
-    recipient = to_checksum_address(recipient)
-    input_data = hex_to_bytes(TRANSFER_METHOD) + eth_abi.encode(["address", "uint256"], [recipient, value])
-    return to_hex(input_data)
-
-
-def transfer_token_legacy(
-    *,
-    rpc_urls: str | Sequence[str],
-    token_address: str,
-    recipient_address: str,
-    value: int,
-    nonce: int,
-    gas_price: int,
-    gas_limit: int,
-    private_key: str,
-    chain_id: int,
-    timeout: int = 10,
-    proxies: Proxies = None,
-    attempts: int = 1,
-) -> Result[str]:
-    input_data = encode_transfer_input_data(recipient_address, value)
-    signed_tx = sign_legacy_tx(
-        nonce=nonce,
-        gas_price=gas_price,
-        gas=gas_limit,
-        private_key=private_key,
-        chain_id=chain_id,
-        data=input_data,
-        to=token_address,
-    )
-    return rpc.eth_send_raw_transaction(rpc_urls, signed_tx.raw_tx, timeout=timeout, proxies=proxies, attempts=attempts)
-
-
-def transfer_token(
-    *,
-    rpc_urls: Nodes,
-    token_address: str,
-    recipient_address: str,
-    value: int,
-    nonce: int,
-    max_fee_per_gas: int,
-    max_priority_fee_per_gas: int,
-    gas_limit: int,
-    private_key: str,
-    chain_id: int,
-    timeout: int = 10,
-    proxies: Proxies = None,
-    attempts: int = 1,
-) -> Result[str]:
-    input_data = encode_transfer_input_data(recipient_address, value)
-    signed_tx = sign_tx(
-        nonce=nonce,
-        max_fee_per_gas=max_fee_per_gas,
-        max_priority_fee_per_gas=max_priority_fee_per_gas,
-        gas=gas_limit,
-        private_key=private_key,
-        chain_id=chain_id,
-        data=input_data,
-        to=token_address,
-    )
-    return rpc.eth_send_raw_transaction(rpc_urls, signed_tx.raw_tx, timeout=timeout, proxies=proxies, attempts=attempts)
+    recipient = eth_utils.to_checksum_address(recipient)
+    input_data = eth_utils.to_bytes(hexstr=HexStr(TRANSFER_METHOD)) + eth_abi.encode(["address", "uint256"], [recipient, value])
+    return eth_utils.to_hex(input_data)
 
 
 def sign_transfer_tx(
@@ -213,7 +28,7 @@ def sign_transfer_tx(
     chain_id: int,
 ) -> SignedTx:
     input_data = encode_transfer_input_data(recipient_address, value)
-    return sign_tx(
+    return tx.sign_tx(
         nonce=nonce,
         max_fee_per_gas=max_fee_per_gas,
         max_priority_fee_per_gas=max_priority_fee_per_gas,
@@ -223,36 +38,3 @@ def sign_transfer_tx(
         data=input_data,
         to=token_address,
     )
-
-
-def get_transfer_event_logs(
-    rpc_urls: Nodes,
-    token_address: str | None,
-    from_block: int,
-    to_block: int,
-    timeout: int = 10,
-    proxies: Proxies = None,
-    attempts: int = 1,
-) -> Result[list[TransferEventLog]]:
-    res = rpc.eth_get_logs(
-        rpc_urls,
-        address=token_address,
-        topics=[TRANSFER_TOPIC],
-        from_block=from_block,
-        to_block=to_block,
-        timeout=timeout,
-        proxies=proxies,
-        attempts=attempts,
-    )
-    if isinstance(res, Err):
-        return res
-    result: list[TransferEventLog] = []
-    for log in res.ok:
-        event_log_res = TransferEventLog.from_log(log)
-        if isinstance(event_log_res, Ok):
-            result.append(event_log_res.ok)
-    return Ok(result, data=res.data)
-
-
-def _normalize_str(value: str) -> Ok[str]:
-    return Ok("".join(filter(lambda x: x in string.printable, eth_utils.to_text(hexstr=value))).strip())

mm_eth/retry.py

@@ -0,0 +1,143 @@
+from typing import Any, Literal
+
+from eth_typing import BlockIdentifier
+from mm_crypto_utils import Nodes, Proxies, retry_with_node_and_proxy
+from mm_std import Result
+from web3.types import TxReceipt
+
+from mm_eth import rpc
+
+TIMEOUT = 5.0
+
+
+# -- start eth rpc calls --
+
+
+async def eth_block_number(retries: int, nodes: Nodes, proxies: Proxies, *, timeout: float = TIMEOUT) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.eth_block_number(node, timeout, proxy)
+    )
+
+
+async def eth_get_balance(retries: int, nodes: Nodes, proxies: Proxies, *, address: str, timeout: float = TIMEOUT) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.eth_get_balance(node, address, timeout, proxy)
+    )
+
+
+async def eth_chain_id(retries: int, nodes: Nodes, proxies: Proxies, *, timeout: float = TIMEOUT) -> Result[int]:
+    return await retry_with_node_and_proxy(retries, nodes, proxies, lambda node, proxy: rpc.eth_chain_id(node, timeout, proxy))
+
+
+async def eth_get_block_by_number(
+    retries: int,
+    nodes: Nodes,
+    proxies: Proxies,
+    *,
+    block_number: BlockIdentifier,
+    full_transaction: bool = False,
+    timeout: float = TIMEOUT,
+) -> Result[dict[str, Any]]:
+    return await retry_with_node_and_proxy(
+        retries,
+        nodes,
+        proxies,
+        lambda node, proxy: rpc.eth_get_block_by_number(node, block_number, full_transaction, timeout, proxy),
+    )
+
+
+async def eth_get_transaction_count(
+    retries: int, nodes: Nodes, proxies: Proxies, *, address: str, timeout: float = TIMEOUT
+) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.eth_get_transaction_count(node, address, timeout, proxy)
+    )
+
+
+async def eth_estimate_gas(
+    retries: int,
+    nodes: Nodes,
+    proxies: Proxies,
+    *,
+    from_: str,
+    to: str | None = None,
+    value: int | None = 0,
+    data: str | None = None,
+    type_: Literal["0x0", "0x2"] | None = None,
+    timeout: float = TIMEOUT,
+) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.eth_estimate_gas(node, from_, to, value, data, type_, timeout, proxy)
+    )
+
+
+async def eth_send_raw_transaction(
+    retries: int, nodes: Nodes, proxies: Proxies, *, raw_tx: str, timeout: float = TIMEOUT
+) -> Result[str]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.eth_send_raw_transaction(node, raw_tx, timeout, proxy)
+    )
+
+
+async def eth_get_transaction_receipt(
+    retries: int, nodes: Nodes, proxies: Proxies, *, tx_hash: str, timeout: float = TIMEOUT
+) -> Result[TxReceipt]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.eth_get_transaction_receipt(node, tx_hash, timeout, proxy)
+    )
+
+
+# -- end eth rpc calls --
+
+
+# -- start erc20 rpc calls --
+
+
+async def erc20_balance(
+    retries: int, nodes: Nodes, proxies: Proxies, *, token: str, wallet: str, timeout: float = TIMEOUT
+) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries,
+        nodes,
+        proxies,
+        lambda node, proxy: rpc.erc20_balance(node, token=token, wallet=wallet, proxy=proxy, timeout=timeout),
+    )
+
+
+async def erc20_name(retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = TIMEOUT) -> Result[str]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.erc20_name(node, token, timeout, proxy)
+    )
+
+
+async def erc20_symbol(retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = TIMEOUT) -> Result[str]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.erc20_symbol(node, token, timeout, proxy)
+    )
+
+
+async def erc20_decimals(retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = TIMEOUT) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.erc20_decimals(node, token, timeout, proxy)
+    )
+
+
+# -- end erc20 rpc calls --
+
+
+# -- start other --
+
+
+async def get_base_fee_per_gas(retries: int, nodes: Nodes, proxies: Proxies, *, timeout: float = TIMEOUT) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.get_base_fee_per_gas(node, timeout, proxy)
+    )
+
+
+async def get_tx_status(retries: int, nodes: Nodes, proxies: Proxies, *, tx_hash: str, timeout: float = TIMEOUT) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries, nodes, proxies, lambda node, proxy: rpc.get_tx_status(node, tx_hash, timeout, proxy)
+    )
+
+
+# -- end other --