mm-eth 0.1.0__py3-none-any.whl

mm_eth/abi.py

@@ -0,0 +1,130 @@
+import string
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any, cast
+
+import eth_abi
+import eth_utils
+import pydash
+from eth_typing import HexStr
+from pydantic import BaseModel
+from web3 import Web3
+from web3.auto import w3
+from web3.types import ABI, ABIFunction
+
+from mm_eth.utils import hex_to_bytes
+
+
+@dataclass
+class NameTypeValue:
+    name: str
+    type: str
+    value: Any
+
+
+class FunctionInput(BaseModel):
+    function_abi: ABIFunction
+    params: dict[str, Any]
+
+    def decode_params_bytes(self) -> dict[str, Any]:
+        result: dict[str, Any] = {}
+        for k, v in self.params.items():
+            if isinstance(v, bytes):
+                try:
+                    str_value = eth_utils.to_text(v)
+                except UnicodeDecodeError:
+                    str_value = eth_utils.to_hex(v)
+                result[k] = "".join(filter(lambda x: x in string.printable, str_value))
+            else:
+                result[k] = v
+        return result
+
+    def function_signature(self) -> str:
+        inputs = [i["name"] for i in self.function_abi["inputs"]]
+        return self.function_abi["name"] + f"({','.join(inputs)})"
+
+    def to_list(self, decode_bytes: bool = False) -> list[NameTypeValue]:
+        result = []
+        for param in self.function_abi["inputs"]:
+            name = param["name"]
+            type_ = param["type"]
+            value = self.params[name]
+            if decode_bytes and isinstance(value, bytes):
+                try:
+                    value = eth_utils.to_text(value)
+                except UnicodeDecodeError:
+                    value = eth_utils.to_hex(value)
+            result.append(NameTypeValue(name, type_, value))
+        return result
+
+
+def decode_function_input(contract_abi: ABI, tx_input: str) -> FunctionInput:
+    contract = w3.eth.contract(abi=contract_abi)
+    func, params = contract.decode_function_input(HexStr(tx_input))
+    return FunctionInput(function_abi=func.abi, params=params)
+
+
+def get_function_abi(contr_abi: ABI, fn_name: str) -> ABIFunction:
+    abi = pydash.find(contr_abi, lambda x: x.get("name", None) == fn_name and x.get("type", None) == "function")  # type:ignore
+    if not abi:
+        raise ValueError("can't find abi for function: " + fn_name)
+    return cast(ABIFunction, abi)
+
+
+def encode_function_input_by_abi(abi: ABI | ABIFunction, fn_name: str, args: list[Any]) -> HexStr:
+    # if abi is contract_abi, get function_abi
+    if isinstance(abi, Sequence):
+        abi = get_function_abi(abi, fn_name)
+    abi = cast(ABIFunction, abi)
+
+    # need update all address values to checkSum version
+    processed_args = []
+    for idx, arg in enumerate(abi["inputs"]):
+        if arg["type"] == "address":
+            processed_args.append(eth_utils.to_checksum_address(args[idx]))
+        else:
+            processed_args.append(args[idx])
+
+    return Web3().eth.contract(abi=[abi]).encodeABI(fn_name=fn_name, args=processed_args)  # type: ignore[no-any-return]
+
+
+def encode_function_input_by_signature(func_signature: str, args: list[Any]) -> HexStr:
+    if not func_signature.endswith(")"):
+        raise ValueError(f"wrong func_signature={func_signature}. example: func1(uint256,address)")
+    func_signature = func_signature.removesuffix(")")
+    arr = func_signature.split("(")
+    if len(arr) != 2:
+        raise ValueError(f"wrong func_signature={func_signature}. example: func1(uint256,address)")
+    func_name = arr[0]
+    arg_types = [t.strip() for t in arr[1].split(",") if t.strip()]
+    func_abi: ABIFunction = {
+        "name": func_name,
+        "type": "function",
+        "inputs": [{"type": t} for t in arg_types],
+    }
+    return encode_function_input_by_abi(func_abi, func_name, args)
+
+
+def encode_function_signature(func_name_with_types: str) -> HexStr:
+    """input example 'transfer(address,uint256)'"""
+    return HexStr(eth_utils.to_hex(Web3.keccak(text=func_name_with_types))[0:10])
+
+
+def decode_data(types: list[str], data: str) -> tuple[Any, ...]:
+    return eth_abi.decode(types, hex_to_bytes(data))
+
+
+def encode_data(types: list[str], args: list[Any]) -> str:
+    return eth_utils.to_hex(eth_abi.encode(types, args))
+
+
+def parse_function_signatures(contract_abi: ABI) -> dict[str, str]:
+    """returns dict, key: function_name_and_types, value: 4bytes signature"""
+    result: dict[str, str] = {}
+    for item in contract_abi:
+        if item.get("type", None) == "function":
+            function_name = item["name"]
+            types = ",".join([i["type"] for i in item["inputs"]])
+            function_name_and_types = f"{function_name}({types})"
+            result[function_name_and_types] = encode_function_signature(function_name_and_types)
+    return result

mm_eth/account.py

@@ -0,0 +1,70 @@
+from dataclasses import dataclass
+
+import eth_utils
+from eth_account import Account
+from eth_account.hdaccount import Mnemonic
+from eth_keys import KeyAPI
+from eth_typing import ChecksumAddress
+from eth_utils import decode_hex
+
+Account.enable_unaudited_hdwallet_features()  # type: ignore[no-untyped-call]
+
+key_api = KeyAPI()
+
+
+@dataclass
+class NewAccount:
+    path: str
+    address: str
+    private_key: str
+
+
+def to_checksum_address(address: str) -> ChecksumAddress:
+    return eth_utils.to_checksum_address(address)
+
+
+def generate_mnemonic(num_words: int = 24) -> str:
+    mnemonic = Mnemonic("english")  # type: ignore[no-untyped-call]
+    return mnemonic.generate(num_words=num_words)
+
+
+def generate_accounts(  # nosec
+    mnemonic: str,
+    passphrase: str = "",
+    path_prefix: str = "m/44'/60'/0'/0",
+    limit: int = 12,
+) -> list[NewAccount]:
+    result: list[NewAccount] = []
+    for i in range(limit):
+        path = f"{path_prefix}/{i}"
+        acc = Account.from_mnemonic(mnemonic=mnemonic, account_path=path, passphrase=passphrase)
+        result.append(NewAccount(path, acc.address, acc.key.hex()))
+    return result
+
+
+def private_to_address(private_key: str) -> str | None:
+    """returns address in lower case"""
+    # noinspection PyBroadException
+    try:
+        return key_api.PrivateKey(decode_hex(private_key)).public_key.to_address().lower()
+    except Exception:
+        return None
+
+
+def create_private_keys_dict(private_keys: list[str]) -> dict[str, str]:  # address in lower
+    result = {}
+    for private_key in private_keys:
+        address = private_to_address(private_key)
+        if address is None:
+            raise ValueError("wrong private key")
+        result[address.lower()] = private_key
+    return result
+
+
+def is_private_key(private_key: str) -> bool:
+    # noinspection PyBroadException
+    try:
+        key_api.PrivateKey(decode_hex(private_key)).public_key.to_address()
+        return True
+    except Exception:
+        return False

mm_eth/anvil.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import time
+from subprocess import Popen  # nosec
+
+from mm_std import Err, Ok, Result
+from mm_std.net import get_free_local_port
+
+from mm_eth import account, rpc
+
+
+class Anvil:
+    def __init__(self, *, chain_id: int, port: int, mnemonic: str):
+        self.chain_id = chain_id
+        self.port = port
+        self.mnemonic = mnemonic
+        self.process: Popen | None = None  # type: ignore[type-arg]
+
+    def start_process(self) -> None:
+        cmd = f"anvil -m '{self.mnemonic}' -p {self.port} --chain-id {self.chain_id}"
+        self.process = Popen(cmd, shell=True)  # nosec
+        time.sleep(3)
+
+    def stop(self) -> None:
+        if self.process:
+            self.process.kill()
+
+    def check(self) -> bool:
+        res = rpc.eth_chain_id(self.rpc_url)
+        return isinstance(res, Ok) and res.ok == self.chain_id
+
+    @property
+    def rpc_url(self) -> str:
+        return f"http://localhost:{self.port}"
+
+    @classmethod
+    def launch(
+        cls,
+        chain_id: int = 31337,
+        port: int | None = None,
+        mnemonic: str = "",
+        attempts: int = 3,
+    ) -> Result[Anvil]:
+        if not mnemonic:
+            mnemonic = account.generate_mnemonic()
+
+        for _ in range(attempts):
+            if not port:
+                port = get_free_local_port()
+            anvil = Anvil(chain_id=chain_id, port=port, mnemonic=mnemonic)
+            anvil.start_process()
+            if anvil.check():
+                return Ok(anvil)
+            port = get_free_local_port()
+
+        return Err("can't lauch anvil")

mm_eth/cli/calcs.py

@@ -0,0 +1,88 @@
+import random
+from decimal import Decimal
+
+from mm_std.random_ import random_decimal
+from mm_std.str import split_on_plus_minus_tokens
+
+from mm_eth.utils import to_wei
+
+
+def calc_var_wei_value(value: str, *, var_name: str = "var", var_value: int | None = None, decimals: int | None = None) -> int:
+    if not isinstance(value, str):
+        raise ValueError(f"value is not str: {value}")
+    try:
+        var_name = var_name.lower()
+        result = 0
+        for item in split_on_plus_minus_tokens(value.lower()):
+            operator = item[0]
+            item = item[1:]
+            if item.isdigit():
+                item_value = int(item)
+            elif item.endswith("eth"):
+                item = item.removesuffix("eth")
+                item_value = int(Decimal(item) * 10**18)
+            elif item.endswith("ether"):
+                item = item.removesuffix("ether")
+                item_value = int(Decimal(item) * 10**18)
+            elif item.endswith("gwei"):
+                item = item.removesuffix("gwei")
+                item_value = int(Decimal(item) * 10**9)
+            elif item.endswith("t"):
+                if decimals is None:
+                    raise ValueError("t without decimals")
+                item = item.removesuffix("t")
+                item_value = int(Decimal(item) * 10**decimals)
+            elif item.endswith(var_name):
+                if var_value is None:
+                    raise ValueError("base value is not set")
+                item = item.removesuffix(var_name)
+                k = Decimal(item) if item else Decimal(1)
+                item_value = int(k * var_value)
+            elif item.startswith("random(") and item.endswith(")"):
+                item = item.lstrip("random(").rstrip(")")
+                arr = item.split(",")
+                if len(arr) != 2:
+                    raise ValueError(f"wrong value, random part: {value}")
+                from_value = to_wei(arr[0], decimals=decimals)
+                to_value = to_wei(arr[1], decimals=decimals)
+                if from_value > to_value:
+                    raise ValueError(f"wrong value, random part: {value}")
+                item_value = random.randint(from_value, to_value)
+            else:
+                raise ValueError(f"wrong value: {value}")
+
+            if operator == "+":
+                result += item_value
+            if operator == "-":
+                result -= item_value
+
+        return result
+    except Exception as err:
+        raise ValueError(f"wrong value: {value}, error={err}") from err
+
+
+def calc_decimal_value(value: str) -> Decimal:
+    value = value.lower().strip()
+    if value.startswith("random(") and value.endswith(")"):
+        arr = value.lstrip("random(").rstrip(")").split(",")
+        if len(arr) != 2:
+            raise ValueError(f"wrong value, random part: {value}")
+        from_value = Decimal(arr[0])
+        to_value = Decimal(arr[1])
+        if from_value > to_value:
+            raise ValueError(f"wrong value, random part: {value}")
+        return random_decimal(from_value, to_value)
+    return Decimal(value)
+
+
+def calc_function_args(value: str) -> str:
+    while True:
+        if "random(" not in value:
+            return value
+        start_index = value.index("random(")
+        stop_index = value.index(")", start_index)
+        random_range = [int(v.strip()) for v in value[start_index + 7 : stop_index].split(",")]
+        if len(random_range) != 2:
+            raise ValueError("wrong random(from,to) template")
+        rand_value = str(random.randint(random_range[0], random_range[1]))
+        value = value[0:start_index] + rand_value + value[stop_index + 1 :]

mm_eth/cli/cli.py

@@ -0,0 +1,233 @@
+from enum import Enum
+from typing import Annotated, Union
+
+import typer
+from mm_std import PrintFormat, print_plain
+
+from mm_eth.cli import cli_helpers
+from mm_eth.cli.cmd import (
+    balance_cmd,
+    balances_cmd,
+    call_contract_cmd,
+    config_example_cmd,
+    deploy_cmd,
+    encode_input_data_cmd,
+    mnemonic_cmd,
+    node_cmd,
+    private_key_cmd,
+    rpc_cmd,
+    send_contract_cmd,
+    solc_cmd,
+    token_cmd,
+    transfer_erc20_cmd,
+    transfer_eth_cmd,
+    vault_cmd,
+)
+
+app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
+
+
+class ConfigExample(str, Enum):
+    TRANSFER_ETH = "transfer-eth"
+    TRANSFER_ERC20 = "transfer-erc20"
+    BALANCES = "balances"
+    CALL_CONTRACT = "call-contract"
+
+
+@app.command(name="balance", help="Gen account balance")
+def balance_command(
+    wallet_address: Annotated[str, typer.Argument()],
+    token_address: Annotated[Union[str | None], typer.Option("--token", "-t")] = None,  # noqa UP007
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL")] = "",  # nosec
+    wei: bool = typer.Option(False, "--wei", "-w", help="Print balances in wei units"),
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
+) -> None:
+    balance_cmd.run(rpc_url, wallet_address, token_address, wei, print_format)
+
+
+@app.command(name="token", help="Get token info")
+def token_command(
+    token_address: Annotated[str, typer.Argument()],
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL")] = "",
+) -> None:
+    token_cmd.run(rpc_url, token_address)
+
+
+@app.command(name="node", help="Check RPC url")
+def node_command(
+    urls: Annotated[list[str], typer.Argument()],
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.TABLE,
+    proxy: Annotated[str, typer.Option("--proxy", "-p", help="Proxy")] = "",
+) -> None:
+    node_cmd.run(urls, print_format, proxy)
+
+
+@app.command(name="mnemonic", help="Generate eth accounts based on a mnemonic")
+def mnemonic_command(  # nosec
+    mnemonic: Annotated[str, typer.Option("--mnemonic", "-m")] = "",
+    passphrase: Annotated[str, typer.Option("--passphrase", "-pass")] = "",
+    print_path: bool = typer.Option(False, "--print_path"),
+    path_prefix: Annotated[str, typer.Option("--path")] = "m/44'/60'/0'/0",
+    limit: int = typer.Option(10, "--limit", "-l"),
+    save_file: str = typer.Option("", "--save", "-s", help="Save private keys to a file"),
+) -> None:
+    mnemonic_cmd.run(
+        mnemonic,
+        passphrase=passphrase,
+        print_path=print_path,
+        limit=limit,
+        path_prefix=path_prefix,
+        save_file=save_file,
+    )
+
+
+@app.command(name="private-key", help="Print an address for a private key")
+def private_key_command(private_key: str) -> None:
+    private_key_cmd.run(private_key)
+
+
+@app.command(name="solc", help="Compile a solidity file")
+def solc_command(
+    contract_path: str,
+    tmp_dir: str = "/tmp",  # nosec
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
+) -> None:
+    solc_cmd.run(contract_path, tmp_dir, print_format)
+
+
+@app.command(name="vault", help="Save private keys to vault")
+def vault_command(
+    keys_url: Annotated[
+        str,
+        typer.Option(..., "--url", "-u", help="Url to keys, for example https://vault.site.com:8200/v1/kv/keys1"),
+    ],
+    vault_token: Annotated[
+        str,
+        typer.Option(..., "--token", "-t", prompt=True, hide_input=True, prompt_required=False, help="A vault token"),
+    ],
+    keys_file: Annotated[str, typer.Option(..., "--file", "-f", help="Path to a file with private keys")],
+) -> None:
+    vault_cmd.run(keys_url, vault_token, keys_file)
+
+
+@app.command(name="rpc", help="Call a JSON-RPC method")
+def rpc_command(
+    method: Annotated[str, typer.Argument()] = "",
+    params: Annotated[str, typer.Argument()] = "[]",
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="ETH_RPC_URL", help="RPC node url")] = "",
+    hex2dec: Annotated[bool, typer.Option("--hex2dec", "-d", help="Print result in decimal value")] = False,
+) -> None:
+    rpc_cmd.run(rpc_url, method, params, hex2dec)
+
+
+@app.command(name="transfer-eth", help="Transfer eth / base token from one or many accounts")
+def transfer_eth_command(
+    config_path: str,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances and exit"),
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    emulate: bool = typer.Option(False, "--emulate", "-e", help="Emulate transaction posting"),
+    no_receipt: bool = typer.Option(False, "--no-receipt", "-nr", help="Don't wait for a tx receipt"),
+    debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
+) -> None:
+    transfer_eth_cmd.run(
+        config_path,
+        print_balances=print_balances,
+        print_config=print_config,
+        debug=debug,
+        no_receipt=no_receipt,
+        emulate=emulate,
+    )
+
+
+@app.command(name="transfer-erc20", help="Transfer ERC20 token from one or many accounts")
+def transfer_erc20_command(
+    config_path: str,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances and exit"),
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    emulate: bool = typer.Option(False, "--emulate", "-e", help="Emulate transaction posting"),
+    no_receipt: bool = typer.Option(False, "--no-receipt", "-nr", help="Don't wait for a tx receipt"),
+    debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
+) -> None:
+    transfer_erc20_cmd.run(
+        config_path,
+        print_balances=print_balances,
+        print_config=print_config,
+        debug=debug,
+        no_receipt=no_receipt,
+        emulate=emulate,
+    )
+
+
+@app.command(name="send-contract", help="Send transactions to a contract")
+def send_contract_command(
+    config_path: str,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances and exit"),
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    emulate: bool = typer.Option(False, "--emulate", "-e", help="Emulate transaction posting"),
+    no_receipt: bool = typer.Option(False, "--no-receipt", "-nr", help="Don't wait for a tx receipt"),
+    debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
+) -> None:
+    send_contract_cmd.run(
+        config_path,
+        print_balances=print_balances,
+        print_config=print_config,
+        debug=debug,
+        no_receipt=no_receipt,
+        emulate=emulate,
+    )
+
+
+@app.command(name="balances", help="Print base and ERC20 token balances")
+def balances_command(
+    config_path: str,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only and exit"),
+    nonce: bool = typer.Option(False, "--nonce", "-n", help="Print nonce also"),
+    wei: bool = typer.Option(False, "--wei", "-w", help="Show balances in WEI"),
+) -> None:
+    balances_cmd.run(config_path, print_config, wei, nonce)
+
+
+@app.command(name="call-contract", help="Call a method on a contract")
+def call_contract_command(
+    config_path: str,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only and exit"),
+) -> None:
+    call_contract_cmd.run(config_path, print_config)
+
+
+@app.command(name="deploy", help="Deploy a smart contract onchain")
+def deploy_command(
+    config_path: str,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config only and exit"),
+) -> None:
+    deploy_cmd.run(config_path, print_config=print_config)
+
+
+@app.command(name="config-example", help="Print an example of config for a command")
+def config_example_command(command: Annotated[ConfigExample, typer.Argument()]) -> None:
+    config_example_cmd.run(command)
+
+
+@app.command(name="encode-input-data", help="Encode input data by a function signature")
+def encode_input_data(
+    funtion_signature: str = typer.Argument(help="Function signature, for example: transfer(address, uint256)"),
+    args_str: str = typer.Argument(
+        help="""Function arguments, as an array string. For example: '["0xA659FB44eB5d4bFaC1074Cb426b1b11D58D28308", 123]' """,
+    ),
+) -> None:
+    encode_input_data_cmd.run(funtion_signature, args_str)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        print_plain(f"mm-eth version: {cli_helpers.get_version()}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(_version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=True)) -> None:
+    pass
+
+
+if __name__ == "__main_":
+    app()