mm-eth 0.1.0__py3-none-any.whl

mm_eth/cli/validators.py

@@ -0,0 +1,84 @@
+import os
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+
+from mm_std import str_to_list
+
+from mm_eth.cli import calcs
+from mm_eth.utils import to_wei
+
+
+def wei_validator(v: str | None) -> int | None:
+    if v is None:
+        return None
+    return to_wei(v)
+
+
+def log_validator(v: str | None) -> str | None:
+    if v is None:
+        return None
+    log_file = Path(v).expanduser()
+    log_file.touch(exist_ok=True)
+    if not (log_file.is_file() and os.access(log_file, os.W_OK)):
+        raise ValueError(f"wrong log path: {v}")
+    return v
+
+
+def nodes_validator(v: str | list[str] | None) -> list[str]:
+    if v is None:
+        return []
+    if isinstance(v, str):
+        return str_to_list(v, unique=True, remove_comments=True, split_line=True)
+    return v
+
+
+def addresses_validator(v: str | list[str] | None) -> list[str]:
+    if v is None:
+        return []
+    if isinstance(v, str):
+        return str_to_list(v, unique=True, remove_comments=True, split_line=True, lower=True)
+    return v
+
+
+def delay_validator(v: str | Decimal) -> Decimal | tuple[Decimal, Decimal]:
+    if isinstance(v, int | float):
+        return Decimal(str(v))
+    elif isinstance(v, str):
+        arr = [a.strip() for a in v.split("-")]
+        if len(arr) != 2:
+            raise ValueError("wrong delay value")
+        try:
+            return Decimal(arr[0]), Decimal(arr[1])
+        except InvalidOperation:
+            raise ValueError("wrong delay value") from None
+    raise ValueError("wrong delay value")
+
+
+def is_valid_calc_var_wei_value(value: str | None, base_name: str = "var", decimals: int | None = None) -> bool:
+    if value is None:
+        return True  # check for None on BaseModel.field type level
+    try:
+        calcs.calc_var_wei_value(value, var_value=123, var_name=base_name, decimals=decimals)
+        return True
+    except ValueError:
+        return False
+
+
+def is_valid_calc_decimal_value(value: str | None) -> bool:
+    if value is None:
+        return True  # check for None on BaseModel.field type level
+    try:
+        calcs.calc_decimal_value(value)
+        return True
+    except ValueError:
+        return False
+
+
+def is_valid_calc_function_args(value: str | None) -> bool:
+    if value is None:
+        return True
+    try:
+        calcs.calc_function_args(value)
+        return True
+    except ValueError:
+        return False

mm_eth/deploy.py

@@ -0,0 +1,20 @@
+import eth_utils
+import rlp
+from eth_utils import keccak
+
+from mm_eth import abi
+
+
+def get_deploy_contract_data(contract_bin: str, constructor_types: list[str], constructor_values: list[object]) -> str:
+    constructor_data = ""
+    if constructor_types and constructor_values:
+        constructor_data = abi.encode_data(constructor_types, constructor_values)[2:]
+    return contract_bin + constructor_data
+
+
+def get_contract_address(sender_address: str, nonce: int) -> str:
+    sender_bytes = eth_utils.to_bytes(hexstr=sender_address)
+    raw = rlp.encode([sender_bytes, nonce])
+    h = keccak(raw)
+    address_bytes = h[12:]
+    return eth_utils.to_checksum_address(address_bytes).lower()

mm_eth/ens.py

@@ -0,0 +1,16 @@
+from mm_std import Err, Ok, Result
+
+from mm_eth.types import Nodes, Proxies
+from mm_eth.utils import get_w3, random_node, random_proxy
+
+
+def get_name(nodes: Nodes, address: str, timeout: int = 10, proxies: Proxies = None, attempts: int = 3) -> Result[str]:
+    result = Err("not_started")
+    for _ in range(attempts):
+        try:
+            w3 = get_w3(random_node(nodes), timeout=timeout, proxy=random_proxy(proxies))
+            res = w3.ens.name(w3.to_checksum_address(address))  # type: ignore[union-attr]
+            return Ok(res or "")
+        except Exception as e:
+            result = Err(e)
+    return result

mm_eth/erc20.py

@@ -0,0 +1,240 @@
+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_std import Err, Ok, Result
+
+from mm_eth import rpc
+from mm_eth.rpc import Log
+from mm_eth.tx import SignedTx, sign_legacy_tx, sign_tx
+from mm_eth.types import Nodes, Proxies
+from mm_eth.utils import hex_str_to_int, hex_to_bytes, log_topic_to_address
+
+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)
+
+
+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)
+
+        if len(res.ok) > 66:
+            result = eth_utils.to_int(hexstr=res.ok[0:66])
+        else:
+            result = 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)
+
+
+def sign_transfer_tx(
+    *,
+    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,
+) -> SignedTx:
+    input_data = encode_transfer_input_data(recipient_address, value)
+    return 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,
+    )
+
+
+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/ethernodes.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+
+from mm_std import CHROME_USER_AGENT, Result, hr
+from pydantic import BaseModel, Field
+
+
+class SearchResult(BaseModel):
+    class Node(BaseModel):
+        id: str
+        host: str
+        port: int
+        client: str
+        client_version: str = Field(..., alias="clientVersion")
+        os: str
+        last_update: datetime = Field(..., alias="lastUpdate")
+        country: str
+        in_sync: int | None = Field(None, alias="inSync")
+        isp: str
+
+    draw: int
+    records_total: int = Field(..., alias="recordsTotal")
+    records_filtered: int = Field(..., alias="recordsFiltered")
+    data: list[Node]
+
+
+def search_nodes(offset: int = 0, proxy: str | None = None) -> Result[SearchResult]:
+    url = f"https://www.ethernodes.org/data?draw=1&columns%5B0%5D%5Bdata%5D=id&columns%5B0%5D%5Bname%5D=&columns%5B0%5D%5Bsearchable%5D=true&columns%5B0%5D%5Borderable%5D=true&columns%5B0%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B0%5D%5Bsearch%5D%5Bregex%5D=false&columns%5B1%5D%5Bdata%5D=host&columns%5B1%5D%5Bname%5D=&columns%5B1%5D%5Bsearchable%5D=true&columns%5B1%5D%5Borderable%5D=true&columns%5B1%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B1%5D%5Bsearch%5D%5Bregex%5D=false&columns%5B2%5D%5Bdata%5D=isp&columns%5B2%5D%5Bname%5D=&columns%5B2%5D%5Bsearchable%5D=true&columns%5B2%5D%5Borderable%5D=true&columns%5B2%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B2%5D%5Bsearch%5D%5Bregex%5D=false&columns%5B3%5D%5Bdata%5D=country&columns%5B3%5D%5Bname%5D=&columns%5B3%5D%5Bsearchable%5D=true&columns%5B3%5D%5Borderable%5D=true&columns%5B3%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B3%5D%5Bsearch%5D%5Bregex%5D=false&columns%5B4%5D%5Bdata%5D=client&columns%5B4%5D%5Bname%5D=&columns%5B4%5D%5Bsearchable%5D=true&columns%5B4%5D%5Borderable%5D=true&columns%5B4%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B4%5D%5Bsearch%5D%5Bregex%5D=false&columns%5B5%5D%5Bdata%5D=clientVersion&columns%5B5%5D%5Bname%5D=&columns%5B5%5D%5Bsearchable%5D=true&columns%5B5%5D%5Borderable%5D=true&columns%5B5%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B5%5D%5Bsearch%5D%5Bregex%5D=false&columns%5B6%5D%5Bdata%5D=os&columns%5B6%5D%5Bname%5D=&columns%5B6%5D%5Bsearchable%5D=true&columns%5B6%5D%5Borderable%5D=true&columns%5B6%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B6%5D%5Bsearch%5D%5Bregex%5D=false&columns%5B7%5D%5Bdata%5D=lastUpdate&columns%5B7%5D%5Bname%5D=&columns%5B7%5D%5Bsearchable%5D=true&columns%5B7%5D%5Borderable%5D=true&columns%5B7%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B7%5D%5Bsearch%5D%5Bregex%5D=false&columns%5B8%5D%5Bdata%5D=inSync&columns%5B8%5D%5Bname%5D=&columns%5B8%5D%5Bsearchable%5D=true&columns%5B8%5D%5Borderable%5D=true&columns%5B8%5D%5Bsearch%5D%5Bvalue%5D=&columns%5B8%5D%5Bsearch%5D%5Bregex%5D=false&order%5B0%5D%5Bcolumn%5D=0&order%5B0%5D%5Bdir%5D=asc&search%5Bvalue%5D=&search%5Bregex%5D=false&length=100&start={offset}"
+    res = hr(url, proxy=proxy, user_agent=CHROME_USER_AGENT)
+    if res.is_error():
+        return res.to_err_result()
+    try:
+        return res.to_ok_result(SearchResult(**res.json))
+    except Exception as e:
+        return res.to_err_result(f"exception: {e}")