mm-eth 0.6.2__py3-none-any.whl → 0.7.1__py3-none-any.whl

mm_eth/abi.py

@@ -72,7 +72,7 @@ def encode_function_input_by_abi(abi: ABI | ABIFunction, fn_name: str, args: lis
     # if abi is contract_abi, get function_abi
     if isinstance(abi, Sequence):
         abi = get_function_abi(abi, fn_name)
-    abi = cast(ABIFunction, abi)
+    # abi = cast(ABIFunction, abi)
 
     # need update all address values to checkSum version
     processed_args = []

mm_eth/account.py

@@ -1,12 +1,12 @@
 from dataclasses import dataclass
 
+import eth_utils
 from eth_account import Account
 from eth_account.hdaccount import Mnemonic
 from eth_account.signers.local import LocalAccount
 from eth_account.types import Language
 from eth_keys import KeyAPI
-from eth_utils import decode_hex
-from mm_std import Result
+from mm_result import Result
 
 Account.enable_unaudited_hdwallet_features()
 
@@ -98,7 +98,7 @@ def is_private_key(private_key: str) -> bool:
         bool: True if valid, False otherwise.
     """
     try:
-        key_api.PrivateKey(decode_hex(private_key)).public_key.to_address()
+        key_api.PrivateKey(eth_utils.decode_hex(private_key)).public_key.to_address()
         return True  # noqa: TRY300
     except Exception:
         return False

mm_eth/anvil.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import socket
 import time
 from subprocess import Popen  # nosec
+from typing import cast
 
-from mm_std import Result
-from mm_std.net import get_free_local_port
+from mm_result import Result
 
 from mm_eth import account, rpc
 
@@ -54,3 +55,11 @@ class Anvil:
             port = get_free_local_port()
 
         return Result.err("can't launch anvil")
+
+
+def get_free_local_port() -> int:
+    sock = socket.socket()
+    sock.bind(("", 0))
+    port = sock.getsockname()[1]
+    sock.close()
+    return cast(int, port)

mm_eth/cli/calcs.py

@@ -1,12 +1,11 @@
-import mm_crypto_utils
-from mm_crypto_utils import VarInt
+import mm_web3
 
 from mm_eth.cli.validators import SUFFIX_DECIMALS
 
 
-def calc_eth_expression(expression: str, var: VarInt | None = None) -> int:
-    return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals=SUFFIX_DECIMALS)
+def calc_eth_expression(expression: str, variables: dict[str, int] | None = None) -> int:
+    return mm_web3.calc_expression_with_vars(expression, variables, unit_decimals=SUFFIX_DECIMALS)
 
 
-def calc_token_expression(expression: str, token_decimals: int, var: VarInt | None = None) -> int:
-    return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals={"t": token_decimals})
+def calc_token_expression(expression: str, token_decimals: int, variables: dict[str, int] | None = None) -> int:
+    return mm_web3.calc_expression_with_vars(expression, variables, unit_decimals={"t": token_decimals})

mm_eth/cli/cli.py

@@ -3,10 +3,11 @@ import importlib.metadata
 from pathlib import Path
 from typing import Annotated
 
+import mm_print
 import typer
-from mm_std import PrintFormat, print_plain
 
 from mm_eth.account import DEFAULT_DERIVATION_PATH
+from mm_eth.cli.cli_utils import PrintFormat
 from mm_eth.cli.cmd import balance_cmd, balances_cmd, deploy_cmd, node_cmd, solc_cmd, transfer_cmd
 from mm_eth.cli.cmd.balances_cmd import BalancesCmdParams
 from mm_eth.cli.cmd.deploy_cmd import DeployCmdParams
@@ -124,7 +125,7 @@ def transfer_command(
 
 def version_callback(value: bool) -> None:
     if value:
-        print_plain(f"mm-eth: {importlib.metadata.version('mm-eth')}")
+        mm_print.plain(f"mm-eth: {importlib.metadata.version('mm-eth')}")
         raise typer.Exit
 
 

mm_eth/cli/cli_utils.py

@@ -1,13 +1,21 @@
 import importlib.metadata
+from enum import Enum, unique
 from pathlib import Path
 
-from mm_std import fatal
+import mm_print
 from pydantic import BaseModel
 from rich.table import Table
 
 from mm_eth import rpc
 
 
+@unique
+class PrintFormat(str, Enum):
+    PLAIN = "plain"
+    TABLE = "table"
+    JSON = "json"
+
+
 def public_rpc_url(url: str | None) -> str:
     if not url or url == "1":
         return "https://ethereum-rpc.publicnode.com"
@@ -36,9 +44,9 @@ class BaseConfigParams(BaseModel):
 
 async def check_nodes_for_chain_id(nodes: list[str], chain_id: int) -> None:
     for node in nodes:
-        res = (await rpc.eth_chain_id(node)).unwrap_or_exit("can't get chain_id")
+        res = (await rpc.eth_chain_id(node)).unwrap("can't get chain_id")
         if res != chain_id:
-            fatal(f"node {node} has a wrong chain_id: {res}")
+            mm_print.fatal(f"node {node} has a wrong chain_id: {res}")
 
 
 def add_table_raw(table: Table, *row: object) -> None:

mm_eth/cli/cmd/balance_cmd.py

@@ -1,8 +1,9 @@
 import eth_utils
-from mm_std import PrintFormat, print_json, print_plain
+import mm_print
 
 from mm_eth import converters, rpc
 from mm_eth.cli import cli_utils
+from mm_eth.cli.cli import PrintFormat
 
 
 async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool, print_format: PrintFormat) -> None:
@@ -12,7 +13,7 @@ async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei:
     # nonce
     result["nonce"] = (await rpc.eth_get_transaction_count(rpc_url, wallet_address)).value_or_error()
     if print_format == PrintFormat.PLAIN:
-        print_plain(f"nonce: {result['nonce']}")
+        mm_print.plain(f"nonce: {result['nonce']}")
 
     # eth balance
     result["eth_balance"] = (
@@ -21,18 +22,18 @@ async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei:
         .value_or_error()
     )
     if print_format == PrintFormat.PLAIN:
-        print_plain(f"eth_balance: {result['eth_balance']}")
+        mm_print.plain(f"eth_balance: {result['eth_balance']}")
 
     if token_address:
         # token decimal
         result["token_decimal"] = (await rpc.erc20_decimals(rpc_url, token_address)).value_or_error()
         if print_format == PrintFormat.PLAIN:
-            print_plain(f"token_decimal: {result['token_decimal']}")
+            mm_print.plain(f"token_decimal: {result['token_decimal']}")
 
         # token symbol
         result["token_symbol"] = (await rpc.erc20_symbol(rpc_url, token_address)).value_or_error()
         if print_format == PrintFormat.PLAIN:
-            print_plain(f"token_symbol: {result['token_symbol']}")
+            mm_print.plain(f"token_symbol: {result['token_symbol']}")
 
         # token balance
         result["token_balance"] = (await rpc.erc20_balance(rpc_url, token_address, wallet_address)).value_or_error()
@@ -40,7 +41,7 @@ async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei:
             result["token_balance"] = converters.from_wei(result["token_balance"], "t", decimals=result["token_decimal"])
 
         if print_format == PrintFormat.PLAIN:
-            print_plain(f"token_balance: {result['token_balance']}")
+            mm_print.plain(f"token_balance: {result['token_balance']}")
 
     if print_format == PrintFormat.JSON:
-        print_json(data=result)
+        mm_print.json(data=result)

mm_eth/cli/cmd/balances_cmd.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
 from typing import Annotated
 
-from mm_std import BaseConfig, fatal
+import mm_print
+from mm_web3 import Web3CliConfig
 from pydantic import BeforeValidator
 from rich.live import Live
 from rich.table import Table
@@ -11,7 +12,7 @@ from mm_eth.cli.cli_utils import BaseConfigParams
 from mm_eth.cli.validators import Validators
 
 
-class Config(BaseConfig):
+class Config(Web3CliConfig):
     addresses: Annotated[list[str], BeforeValidator(Validators.eth_addresses(unique=True))]
     tokens: Annotated[list[str], BeforeValidator(Validators.eth_addresses(unique=True))]
     nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
@@ -63,7 +64,7 @@ async def run(params: BalancesCmdParams) -> None:
                 else:
                     row.append(str(converters.from_wei(balance, "eth", round_ndigits=config.round_ndigits)))
             else:
-                row.append(base_balance_res.unwrap_error())
+                row.append(base_balance_res.unwrap_err())
 
             for t in tokens:
                 token_balance_res = await retry.erc20_balance(5, config.nodes, None, token=t.address, wallet=address)
@@ -77,7 +78,7 @@ async def run(params: BalancesCmdParams) -> None:
                             str(converters.from_wei(token_balance, "t", round_ndigits=config.round_ndigits, decimals=t.decimals))
                         )
                 else:
-                    row.append(token_balance_res.unwrap_error())
+                    row.append(token_balance_res.unwrap_err())
 
             table.add_row(*row)
 
@@ -104,12 +105,12 @@ async def _get_tokens_info(config: Config) -> list[Token]:
     for address in config.tokens:
         decimals_res = await retry.erc20_decimals(5, config.nodes, None, token=address)
         if decimals_res.is_err():
-            fatal(f"can't get token {address} decimals: {decimals_res.unwrap_error()}")
+            mm_print.fatal(f"can't get token {address} decimals: {decimals_res.unwrap_err()}")
         decimal = decimals_res.unwrap()
 
         symbols_res = await retry.erc20_symbol(5, config.nodes, None, token=address)
         if symbols_res.is_err():
-            fatal(f"can't get token {address} symbol: {symbols_res.unwrap_error()}")
+            mm_print.fatal(f"can't get token {address} symbol: {symbols_res.unwrap_err()}")
         symbol = symbols_res.unwrap()
 
         result.append(Token(address=address, decimals=decimal, symbol=symbol))

mm_eth/cli/cmd/deploy_cmd.py

@@ -1,13 +1,15 @@
 from typing import cast
 
-from mm_std import BaseConfig, print_console, toml_loads
+import mm_print
+import tomlkit
+from mm_web3 import Web3CliConfig
 from pydantic import StrictStr
 
 from mm_eth import account, deploy, retry
 from mm_eth.cli.cli_utils import BaseConfigParams
 
 
-class Config(BaseConfig):
+class Config(Web3CliConfig):
     private_key: StrictStr
     nonce: int | None = None
     gas: int
@@ -30,7 +32,7 @@ async def run(cli_params: DeployCmdParams) -> None:
     if cli_params.print_config:
         config.print_and_exit({"private_key"})
 
-    parsed = toml_loads(f"constructor_types = {config.constructor_types}\nconstructor_values = {config.constructor_values}")
+    parsed = tomlkit.loads(f"constructor_types = {config.constructor_types}\nconstructor_values = {config.constructor_values}")
     constructor_types = cast(list[str], parsed["constructor_types"])
     constructor_values = cast(list[object], parsed["constructor_values"])
 
@@ -42,4 +44,4 @@ async def run(cli_params: DeployCmdParams) -> None:
         )
 
     res = deploy.get_deploy_contract_data(config.contract_bin, constructor_types, constructor_values)
-    print_console(res)
+    mm_print.json(res)

mm_eth/cli/cmd/node_cmd.py

@@ -1,13 +1,14 @@
 from decimal import Decimal
 
 import eth_utils
+import mm_print
 import pydash
-from mm_std import PrintFormat, print_json
 from pydantic import BaseModel
 from rich.live import Live
 from rich.table import Table
 
 from mm_eth import rpc, utils
+from mm_eth.cli.cli import PrintFormat
 
 
 class NodeInfo(BaseModel):
@@ -57,7 +58,7 @@ async def run(urls: list[str], proxy: str | None, print_format: PrintFormat) ->
     live_table.stop()
 
     if print_format == PrintFormat.JSON:
-        print_json(data=result)
+        mm_print.json(data=result)
     # print_json(data=result)
     # table = Table(*["url", "chain_id", "chain_name", "block_number", "base_fee"], title="nodes")
 

mm_eth/cli/cmd/solc_cmd.py

@@ -1,25 +1,25 @@
 import json
 from pathlib import Path
 
-from mm_std import PrintFormat, fatal, print_json, print_plain
-from mm_std.fs import get_filename_without_extension
+import mm_print
 
+from mm_eth.cli.cli import PrintFormat
 from mm_eth.solc import solc
 
 
 def run(contract_path: Path, tmp_dir: Path, print_format: PrintFormat) -> None:
-    contract_name = get_filename_without_extension(contract_path)
+    contract_name = contract_path.stem
     res = solc(contract_name, contract_path, tmp_dir)
     if res.is_err():
-        fatal(res.unwrap_error())
+        mm_print.fatal(res.unwrap_err())
 
     bin_ = res.unwrap().bin
     abi = res.unwrap().abi
 
     if print_format == PrintFormat.JSON:
-        print_json({"bin": bin_, "abi": json.loads(abi)})
+        mm_print.json({"bin": bin_, "abi": json.loads(abi)})
     else:
-        print_plain("bin:")
-        print_plain(bin_)
-        print_plain("abi:")
-        print_plain(abi)
+        mm_print.plain("bin:")
+        mm_print.plain(bin_)
+        mm_print.plain("abi:")
+        mm_print.plain(abi)

mm_eth/cli/cmd/transfer_cmd.py

@@ -4,10 +4,9 @@ import time
 from pathlib import Path
 from typing import Annotated, Literal, Self, cast
 
-import mm_crypto_utils
 from loguru import logger
-from mm_crypto_utils import AddressToPrivate, Transfer, VarInt
-from mm_std import BaseConfig, utc_now
+from mm_std import utc_now
+from mm_web3 import PrivateKeyMap, Transfer, Web3CliConfig, calc_decimal_expression, init_loguru
 from pydantic import AfterValidator, BeforeValidator, Field, model_validator
 from rich.console import Console
 from rich.live import Live
@@ -20,11 +19,11 @@ from mm_eth.cli.validators import Validators
 from mm_eth.converters import from_wei
 
 
-class Config(BaseConfig):
+class Config(Web3CliConfig):
     nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
     chain_id: int
     transfers: Annotated[list[Transfer], BeforeValidator(Validators.eth_transfers())]
-    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.eth_private_keys())]
+    private_keys: Annotated[PrivateKeyMap, BeforeValidator(Validators.eth_private_keys())]
     token: Annotated[str | None, AfterValidator(Validators.eth_address())] = None  # if None, then eth transfer
     token_decimals: int = -1
     max_fee: Annotated[str, AfterValidator(Validators.valid_eth_expression("base_fee"))]
@@ -33,7 +32,7 @@ class Config(BaseConfig):
     default_value: Annotated[str | None, AfterValidator(Validators.valid_eth_or_token_expression("balance"))] = None
     value_min_limit: Annotated[str | None, AfterValidator(Validators.valid_eth_or_token_expression())] = None
     gas: Annotated[str, AfterValidator(Validators.valid_eth_expression("estimate"))]
-    delay: Annotated[str | None, AfterValidator(Validators.valid_calc_decimal_value())] = None  # in seconds
+    delay: Annotated[str | None, AfterValidator(Validators.decimal_expression())] = None  # in seconds
     round_ndigits: int = 5
     proxies: Annotated[list[str], Field(default_factory=list), BeforeValidator(Validators.proxies())]
     wait_tx_timeout: int = 120
@@ -68,7 +67,7 @@ class Config(BaseConfig):
                 Validators.valid_eth_expression()(self.value_min_limit)
 
         if self.token:
-            self.token_decimals = (await retry.erc20_decimals(5, self.nodes, self.proxies, token=self.token)).unwrap_or_exit(
+            self.token_decimals = (await retry.erc20_decimals(5, self.nodes, self.proxies, token=self.token)).unwrap(
                 "can't get token decimals"
             )
 
@@ -102,13 +101,13 @@ async def run(params: TransferCmdParams) -> None:
 
 
 async def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
-    mm_crypto_utils.init_logger(cmd_params.debug, config.log_debug, config.log_info)
+    init_loguru(cmd_params.debug, config.log_debug, config.log_info)
     logger.info(f"transfer {cmd_params.config_path}: started at {utc_now()} UTC")
     logger.debug(f"config={config.model_dump(exclude={'private_keys'}) | {'version': cli_utils.get_version()}}")
     for i, transfer in enumerate(config.transfers):
         await _transfer(transfer, config, cmd_params)
         if config.delay is not None and i < len(config.transfers) - 1:
-            delay_value = mm_crypto_utils.calc_decimal_value(config.delay)
+            delay_value = calc_decimal_expression(config.delay)
             logger.info(f"delay {delay_value} seconds")
             if not cmd_params.emulate:
                 await asyncio.sleep(float(delay_value))
@@ -118,7 +117,7 @@ async def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
 async def _get_nonce(t: Transfer, config: Config) -> int | None:
     res = await retry.eth_get_transaction_count(5, config.nodes, config.proxies, address=t.from_address)
     if res.is_err():
-        logger.error(f"{t.log_prefix}: nonce error: {res.unwrap_error()}")
+        logger.error(f"{t.log_prefix}: nonce error: {res.unwrap_err()}")
         return None
     logger.debug(f"{t.log_prefix}: nonce={res.unwrap()}")
     return res.unwrap()
@@ -128,10 +127,10 @@ async def _calc_max_fee(t: Transfer, config: Config) -> int | None:
     if "base_fee" in config.max_fee.lower():
         base_fee_res = await retry.get_base_fee_per_gas(5, config.nodes, config.proxies)
         if base_fee_res.is_err():
-            logger.error(f"{t.log_prefix}: base_fee error: {base_fee_res.unwrap_error()}")
+            logger.error(f"{t.log_prefix}: base_fee error: {base_fee_res.unwrap_err()}")
             return None
         logger.debug(f"{t.log_prefix}: base_fee={base_fee_res.unwrap()}")
-        return calcs.calc_eth_expression(config.max_fee, VarInt("base_fee", base_fee_res.unwrap()))
+        return calcs.calc_eth_expression(config.max_fee, {"base_fee": base_fee_res.unwrap()})
     return calcs.calc_eth_expression(config.max_fee)
 
 
@@ -147,7 +146,7 @@ def check_max_fee_limit(t: Transfer, config: Config, max_fee: int) -> bool:
 
 
 async def _calc_gas(t: Transfer, config: Config) -> int | None:
-    var = None
+    variables: dict[str, int] | None = None
     if "estimate" in config.gas.lower():
         if config.token:
             res = await retry.eth_estimate_gas(
@@ -163,25 +162,25 @@ async def _calc_gas(t: Transfer, config: Config) -> int | None:
                 5, config.nodes, config.proxies, from_=t.from_address, to=t.to_address, value=12345
             )
         if res.is_err():
-            logger.error(f"{t.log_prefix}: gas estimate error: {res.unwrap_error()}")
+            logger.error(f"{t.log_prefix}: gas estimate error: {res.unwrap_err()}")
             return None
         logger.debug(f"{t.log_prefix}: gas estimate={res.unwrap()}")
-        var = VarInt("estimate", res.unwrap())
-    return calcs.calc_eth_expression(config.gas, var)
+        variables = {"estimate": res.unwrap()}
+    return calcs.calc_eth_expression(config.gas, variables)
 
 
 async def _calc_eth_value(t: Transfer, max_fee: int, gas: int, config: Config) -> int | None:
     value_expression = t.value.lower()
-    var = None
+    variables: dict[str, int] | None = None
     if "balance" in value_expression:
         res = await retry.eth_get_balance(5, config.nodes, config.proxies, address=t.from_address)
         if res.is_err():
-            logger.error(f"{t.log_prefix}: balance error: {res.unwrap_error()}")
+            logger.error(f"{t.log_prefix}: balance error: {res.unwrap_err()}")
             return None
         logger.debug(f"{t.log_prefix}: balance={res.unwrap()}")
-        var = VarInt("balance", res.unwrap())
+        variables = {"balance": res.unwrap()}
 
-    value = calcs.calc_eth_expression(value_expression, var)
+    value = calcs.calc_eth_expression(value_expression, variables)
     if "balance" in value_expression.lower():
         value = value - gas * max_fee
     return value
@@ -189,15 +188,15 @@ async def _calc_eth_value(t: Transfer, max_fee: int, gas: int, config: Config) -
 
 async def _calc_token_value(t: Transfer, config: Config) -> int | None:
     value_expression = t.value.lower()
-    var = None
+    variables: dict[str, int] | None = None
     if "balance" in value_expression:
         res = await retry.erc20_balance(5, config.nodes, config.proxies, token=cast(str, config.token), wallet=t.from_address)
         if res.is_err():
-            logger.error(f"{t.log_prefix}: balance error: {res.unwrap_error()}")
+            logger.error(f"{t.log_prefix}: balance error: {res.unwrap_err()}")
             return None
         logger.debug(f"{t.log_prefix}: balance={res.unwrap()}")
-        var = VarInt("balance", res.unwrap())
-    return calcs.calc_token_expression(value_expression, config.token_decimals, var)
+        variables = {"balance": res.unwrap()}
+    return calcs.calc_token_expression(value_expression, config.token_decimals, variables)
 
 
 async def _calc_value(t: Transfer, max_fee: int, gas: int, config: Config) -> int | None:
@@ -321,7 +320,7 @@ async def _send_tx(
         )
     res = await retry.eth_send_raw_transaction(5, config.nodes, config.proxies, raw_tx=signed_tx.raw_tx)
     if res.is_err():
-        logger.error(f"{transfer.log_prefix}: send tx error={res.unwrap_error()}")
+        logger.error(f"{transfer.log_prefix}: send tx error={res.unwrap_err()}")
         return None
     logger.debug(f"{transfer.log_prefix}: tx_hash={res.unwrap()}")
 

mm_eth/cli/cmd/wallet/mnemonic_cmd.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 from typing import Any
 
-from mm_std import print_json
+import mm_print
 
 from mm_eth.account import derive_accounts, generate_mnemonic
 
@@ -19,7 +19,7 @@ def run(mnemonic: str, passphrase: str, words: int, derivation_path: str, limit:
         if print_path:
             new_account["path"] = acc.path
         result["accounts"].append(new_account)
-    print_json(result)
+    mm_print.json(result)
 
     if save_file:
         data = [acc["address"] + "\t" + acc["private"] for acc in result["accounts"]]

mm_eth/cli/cmd/wallet/private_key_cmd.py

@@ -1,4 +1,4 @@
-from mm_std import fatal, print_plain
+import mm_print
 
 from mm_eth import account
 
@@ -6,6 +6,6 @@ from mm_eth import account
 def run(private_key: str) -> None:
     res = account.private_to_address(private_key)
     if res.is_ok():
-        print_plain(res.unwrap())
+        mm_print.plain(res.unwrap())
     else:
-        fatal(f"invalid private key: '{private_key}'")
+        mm_print.fatal(f"invalid private key: '{private_key}'")

mm_eth/cli/rpc_helpers.py

@@ -1,6 +1,6 @@
 import logging
 
-from mm_crypto_utils import Nodes, Proxies, VarInt
+from mm_web3 import Nodes, Proxies
 
 from mm_eth import retry
 from mm_eth.cli import calcs
@@ -14,7 +14,7 @@ async def get_nonce_with_logging(
     res = await retry.eth_get_transaction_count(retries, nodes, proxies, address=address)
     prefix = log_prefix or address
     if res.is_err():
-        logger.error(f"{prefix}: nonce error: {res.unwrap_error()}")
+        logger.error(f"{prefix}: nonce error: {res.unwrap_err()}")
         return None
     logger.debug(f"{prefix}: nonce={res.unwrap()}")
     return res.unwrap()
@@ -24,7 +24,7 @@ async def get_base_fee_with_logging(log_prefix: str | None, retries: int, nodes:
     prefix = get_log_prefix(log_prefix)
     res = await retry.get_base_fee_per_gas(retries, nodes, proxies)
     if res.is_err():
-        logger.error(f"{prefix}base_fee error, {res.unwrap_error()}")
+        logger.error(f"{prefix}base_fee error, {res.unwrap_err()}")
         return None
 
     logger.debug(f"{prefix}base_fee={res.unwrap()}")
@@ -38,7 +38,7 @@ async def calc_max_fee_with_logging(
         base_fee = await get_base_fee_with_logging(log_prefix, retries, nodes, proxies)
         if base_fee is None:
             return None
-        return calcs.calc_eth_expression(max_fee_expression, VarInt("base_fee", base_fee))
+        return calcs.calc_eth_expression(max_fee_expression, {"base_fee": base_fee})
 
     return calcs.calc_eth_expression(max_fee_expression)
 

mm_eth/cli/validators.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 
 import eth_utils
-from mm_crypto_utils import AddressToPrivate, ConfigValidators, Transfer
+from mm_web3 import ConfigValidators, PrivateKeyMap, Transfer
 
 from mm_eth import account
 
@@ -18,28 +18,28 @@ def address_from_private(private_key: str) -> str:
 class Validators(ConfigValidators):
     @staticmethod
     def valid_eth_expression(var_name: str | None = None) -> Callable[[str], str]:
-        return ConfigValidators.valid_calc_int_expression(var_name, SUFFIX_DECIMALS)
+        return ConfigValidators.expression_with_vars(var_name, SUFFIX_DECIMALS)
 
     @staticmethod
     def valid_token_expression(var_name: str | None = None) -> Callable[[str], str]:
-        return ConfigValidators.valid_calc_int_expression(var_name, {"t": 6})
+        return ConfigValidators.expression_with_vars(var_name, {"t": 6})
 
     @staticmethod
     def valid_eth_or_token_expression(var_name: str | None = None) -> Callable[[str], str]:
-        return ConfigValidators.valid_calc_int_expression(var_name, SUFFIX_DECIMALS | {"t": 6})
+        return ConfigValidators.expression_with_vars(var_name, SUFFIX_DECIMALS | {"t": 6})
 
     @staticmethod
     def eth_transfers() -> Callable[[str], list[Transfer]]:
-        return ConfigValidators.transfers(is_address=eth_utils.is_address, to_lower=True)
+        return ConfigValidators.transfers(is_address=eth_utils.is_address, lowercase=True)
 
     @staticmethod
-    def eth_private_keys() -> Callable[[str], AddressToPrivate]:
+    def eth_private_keys() -> Callable[[str], PrivateKeyMap]:
         return ConfigValidators.private_keys(address_from_private)
 
     @staticmethod
     def eth_address() -> Callable[[str], str]:
-        return ConfigValidators.address(eth_utils.is_address, to_lower=True)
+        return ConfigValidators.address(eth_utils.is_address, lowercase=True)
 
     @staticmethod
     def eth_addresses(unique: bool) -> Callable[[str], list[str]]:
-        return ConfigValidators.addresses(unique, to_lower=True, is_address=eth_utils.is_address)
+        return ConfigValidators.addresses(unique, lowercase=True, is_address=eth_utils.is_address)

mm_eth/retry.py

@@ -1,8 +1,8 @@
 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 mm_result import Result
+from mm_web3 import Nodes, Proxies, retry_with_node_and_proxy
 from web3.types import TxReceipt
 
 from mm_eth import rpc

mm_eth/rpc.py

@@ -9,7 +9,8 @@ import eth_utils
 import pydash
 import websockets
 from eth_typing import BlockIdentifier
-from mm_std import Result, http_request
+from mm_http import http_request
+from mm_result import Result
 from web3.types import TxReceipt
 
 TIMEOUT = 7.0
@@ -32,17 +33,17 @@ async def rpc_call(
 async def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
     res = await http_request(node, method="POST", proxy=proxy, timeout=timeout, json=data)
     if res.is_err():
-        return res.to_err()
+        return res.to_result_err()
     try:
         parsed_body = res.parse_json_body()
         err = parsed_body.get("error", {}).get("message", "")
         if err:
-            return res.to_err(f"service_error: {err}")
+            return res.to_result_err(f"service_error: {err}")
         if "result" in parsed_body:
-            return res.to_ok(parsed_body["result"])
-        return res.to_ok("unknown_response")
+            return res.to_result_ok(parsed_body["result"])
+        return res.to_result_err("unknown_response")
     except Exception as e:
-        return res.to_err(e)
+        return res.to_result_err(e)
 
 
 async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result[Any]:
@@ -225,7 +226,7 @@ async def ens_name(node: str, address: str, timeout: float = TIMEOUT, proxy: str
     extra["name_response"] = name_res.to_dict()
 
     if name_res.is_err():
-        return Result.err(name_res.unwrap_error(), extra)
+        return Result.err(name_res.unwrap_err(), extra)
 
     if name_res.unwrap() == "0x":
         return Result.ok(None, extra)
@@ -248,7 +249,7 @@ async def ens_name(node: str, address: str, timeout: float = TIMEOUT, proxy: str
 async def get_base_fee_per_gas(node: str, timeout: float = TIMEOUT, proxy: str | None = None) -> Result[int]:
     res = await eth_get_block_by_number(node, "latest", False, timeout=timeout, proxy=proxy)
     if res.is_err():
-        return Result.err(res.unwrap_error(), res.extra)
+        return Result.err(res.unwrap_err(), res.extra)
     if "baseFeePerGas" in res.unwrap():
         return res.with_value(int(res.unwrap()["baseFeePerGas"], 16))
     return Result.err("no_base_fee_per_gas", res.extra)
@@ -257,7 +258,7 @@ async def get_base_fee_per_gas(node: str, timeout: float = TIMEOUT, proxy: str |
 async def get_tx_status(node: str, tx_hash: str, timeout: float = TIMEOUT, proxy: str | None = None) -> Result[int]:
     res = await eth_get_transaction_receipt(node, tx_hash, timeout=timeout, proxy=proxy)
     if res.is_err():
-        return Result.err(res.unwrap_error(), res.extra)
+        return Result.err(res.unwrap_err(), res.extra)
     status = res.unwrap().get("status")
     if status is None:
         return Result.err("no_status", res.extra)

mm_eth/solc.py

@@ -4,7 +4,8 @@ import shutil
 from dataclasses import dataclass
 from pathlib import Path
 
-from mm_std import Result, run_command
+import mm_std
+from mm_result import Result
 
 
 @dataclass
@@ -31,7 +32,7 @@ def solc(contract_name: str, contract_path: Path, tmp_dir: Path) -> Result[SolcR
         work_dir_created = True
 
         cmd = f"solc -o '{work_dir}' --abi --bin --optimize '{contract_path}'"
-        result = run_command(cmd)
+        result = mm_std.shell(cmd)
         if result.code != 0:
             return Result.err(f"solc error: {result.stderr}")
 

mm_eth/tx.py

@@ -6,7 +6,6 @@ import eth_utils
 import rlp
 from eth_account import Account
 from eth_typing import HexStr
-from eth_utils import keccak, to_hex
 from pydantic import BaseModel
 from rlp.sedes import Binary, big_endian_int, binary
 from web3 import Web3
@@ -103,7 +102,7 @@ def sign_legacy_tx(
         tx["data"] = data
 
     signed = Account.sign_transaction(tx, private_key)
-    return SignedTx(tx_hash=to_hex(signed.hash), raw_tx=to_hex(signed.raw_transaction))
+    return SignedTx(tx_hash=eth_utils.to_hex(signed.hash), raw_tx=eth_utils.to_hex(signed.raw_transaction))
 
 
 def sign_tx(
@@ -139,7 +138,7 @@ def sign_tx(
 
 def decode_raw_tx(raw_tx: str) -> DecodedRawTx:
     tx: Any = rlp.decode(eth_utils.to_bytes(hexstr=HexStr(raw_tx)), RPLTransaction)
-    tx_hash = Web3.to_hex(keccak(eth_utils.to_bytes(hexstr=HexStr(raw_tx))))
+    tx_hash = Web3.to_hex(eth_utils.keccak(eth_utils.to_bytes(hexstr=HexStr(raw_tx))))
     from_ = Account.recover_transaction(raw_tx)
     to = Web3.to_checksum_address(tx.to) if tx.to else None
     data = Web3.to_hex(tx.data)

mm_eth-0.7.1.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mm-eth
+Version: 0.7.1
+Requires-Python: >=3.13
+Requires-Dist: mm-web3~=0.5.1
+Requires-Dist: typer~=0.16.0
+Requires-Dist: web3~=7.12.0

mm_eth-0.7.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+mm_eth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/abi.py,sha256=SBst1GqcaMSawAyAragAx8tYkCThw0aiMmsWa884wyA,4808
+mm_eth/account.py,sha256=WUaQq8AtHIL39hJN4-UkhDu7UM20j1xlMplCTKQzr1o,3041
+mm_eth/anvil.py,sha256=f7zd5zZqcOTd1Sy4GdHAGTOjsQZzLI3E0ttT017KYLQ,1792
+mm_eth/converters.py,sha256=smL3Bsky1pYEre2kPhsb4arXoQC_u80P5ilU9NRvr44,2043
+mm_eth/deploy.py,sha256=SB3ruY808_5UnG8kHR34uVP66P3zOWZu0ImKD7UUv2s,691
+mm_eth/erc20.py,sha256=Pxs_w95flqEUF4pJMoaHTfvud8x5Fb2UwU7iwMjdGCw,1143
+mm_eth/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/retry.py,sha256=saRYV07Ca1laqT1nQP3_UmKvYXNWMURh8gyN2r1WrIs,5123
+mm_eth/rpc.py,sha256=3I6mfM_-93qFK25SLwv8zUG2vR5EaEUd_YfcBVX8YF0,9917
+mm_eth/solc.py,sha256=s_iaaslncVzzQsgUgcc04x8ZeCjCf9T9JdW1_yzUDxI,1353
+mm_eth/tx.py,sha256=MSJf6zGRYlwCbJIXXLL2NONVpvF1_clWd_5CV5j4pTE,4095
+mm_eth/utils.py,sha256=TLyapZZ1lp_kW3vdkHmgR8gUtIQ1aEy_0GScxB6v5IQ,659
+mm_eth/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/calcs.py,sha256=FwnYwRKDnBdXTYrjdWqilPd36W969ovziO8qkQoHOsw,477
+mm_eth/cli/cli.py,sha256=aElAbK1FiABwMPTU-vysyFIyg6OkBtiir6Zj4LuNmx8,5600
+mm_eth/cli/cli_utils.py,sha256=Py04-0wI5_6Hby0zN8WxYFZf0jL13B1gxjjYTIDrqOE,1536
+mm_eth/cli/rpc_helpers.py,sha256=nmr4CXVMGblGJxllaLd95gTV_VhauRhWUKmQZk5-Vmg,1643
+mm_eth/cli/validators.py,sha256=0T5tQdqEd4fNaamVK8TifUBTCzqLkNdzTA4rZD98_H8,1649
+mm_eth/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/cmd/balance_cmd.py,sha256=Qtn_4h_MDYh38HizkOx6auAv0_41GyCH3bWDmLXHfjQ,1963
+mm_eth/cli/cmd/balances_cmd.py,sha256=I8GgANCx5vuu8Yb5qOrlcKdUc-Yzw1eg9Ucrran5xnQ,4256
+mm_eth/cli/cmd/deploy_cmd.py,sha256=ge-r_GbGc9r2osz-g7zOmqXkbMsFnjeyNPSoq72Ntpg,1479
+mm_eth/cli/cmd/node_cmd.py,sha256=-BBKj9l-ZiPr6NZ12WQvuxQcXvyDBvcbReMMevN3fME,2574
+mm_eth/cli/cmd/solc_cmd.py,sha256=Puu8mw8wvbltEug7SCMZdNT5Y9tD_-awdKGYKeYHUsw,648
+mm_eth/cli/cmd/transfer_cmd.py,sha256=6ciWTPdnu6dnv0H0c641kgar2nG4aJOxl0G0lszxD4M,16978
+mm_eth/cli/cmd/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/cmd/wallet/mnemonic_cmd.py,sha256=RQbNY3C4-5NvcPXorhO7YIYG8dU0u5gN5sEANmFE1iY,996
+mm_eth/cli/cmd/wallet/private_key_cmd.py,sha256=RmSrUxaGd0U7f6Xo_CZuJ8XQG9PbjI3Tc1Iu7wzkP3Q,262
+mm_eth-0.7.1.dist-info/METADATA,sha256=mqbTSkJIF14yJ9FAJokEFQMkJykqHSrqwidE8NyEppU,161
+mm_eth-0.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_eth-0.7.1.dist-info/entry_points.txt,sha256=aGhpsozl8NIrkuUcX5fSgURCcDhr3ShUdeTSIrJq4oc,46
+mm_eth-0.7.1.dist-info/RECORD,,

mm_eth-0.6.2.dist-info/METADATA

@@ -1,10 +0,0 @@
-Metadata-Version: 2.4
-Name: mm-eth
-Version: 0.6.2
-Requires-Python: >=3.12
-Requires-Dist: aiohttp-socks~=0.10.1
-Requires-Dist: mm-crypto-utils>=0.3.6
-Requires-Dist: mm-std~=0.4.11
-Requires-Dist: typer>=0.15.2
-Requires-Dist: web3~=7.10.0
-Requires-Dist: websocket-client~=1.8.0

mm_eth-0.6.2.dist-info/RECORD

@@ -1,33 +0,0 @@
-mm_eth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_eth/abi.py,sha256=gsIsaq5V8QGdYY424c_t_uVRfg0of7Gk9h0LcW3tkjU,4806
-mm_eth/account.py,sha256=syA89ihOBTA2FiDK3o55oLBVEgPN1rQT_3bUQN05vuk,3044
-mm_eth/anvil.py,sha256=NY1TxYnamfm_47HqCbgUCRdQxPgmAcJ-9YkK3NZ0310,1631
-mm_eth/converters.py,sha256=smL3Bsky1pYEre2kPhsb4arXoQC_u80P5ilU9NRvr44,2043
-mm_eth/deploy.py,sha256=SB3ruY808_5UnG8kHR34uVP66P3zOWZu0ImKD7UUv2s,691
-mm_eth/erc20.py,sha256=Pxs_w95flqEUF4pJMoaHTfvud8x5Fb2UwU7iwMjdGCw,1143
-mm_eth/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_eth/retry.py,sha256=tYP7B_lah8hxYahweaGAAhWCJl-pQ0pg_2Lk-432luE,5128
-mm_eth/rpc.py,sha256=sFt9vK6rHktNTAIxgKx9CSCANx9Z7tTp165yK_G3uRs,9865
-mm_eth/solc.py,sha256=2FGCJpbkCwIs8hGc8APpvC62gyAXGLeyQMrn4f9Bnow,1348
-mm_eth/tx.py,sha256=zf5fieuKB-CTOiNNjz3siXU7yga7tlh0vkZTDAHvhnQ,4102
-mm_eth/utils.py,sha256=TLyapZZ1lp_kW3vdkHmgR8gUtIQ1aEy_0GScxB6v5IQ,659
-mm_eth/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_eth/cli/calcs.py,sha256=N063Qw85iBNFbDtIjOSYJKHL0vU6wyfRfYAlI9TKeK0,496
-mm_eth/cli/cli.py,sha256=Qac0HizKAyF1wocVvNK2578ntB2JT9kLHr1U5jfQj6E,5580
-mm_eth/cli/cli_utils.py,sha256=jYDuSo-osvKPkd_OJFCHZDfGlFy3LKs-MVKHEnkCPdM,1416
-mm_eth/cli/rpc_helpers.py,sha256=5fxiwFb16V0udY2MOb3bTpUrkf3Lhn-mMXFrdbmAKo4,1669
-mm_eth/cli/validators.py,sha256=74AxIzryQ-D3f5xJYrOnh4AMFugTpsYhUJ_pzhHd2ek,1675
-mm_eth/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_eth/cli/cmd/balance_cmd.py,sha256=hujMv4Fvt4ZMZ3iPOZKdI2u2iN-ClYBmfMn_2Y4lRew,1946
-mm_eth/cli/cmd/balances_cmd.py,sha256=VGCqcPCKPFF2O3WNlryg0nFnCkkKRAaubvpbtH0XTV0,4230
-mm_eth/cli/cmd/deploy_cmd.py,sha256=T0VapUVOA6M5Hska04AObBKk5_91lClX5hARkj1Dm3k,1465
-mm_eth/cli/cmd/node_cmd.py,sha256=JJSiKGG5OL9p7FuHhNeerjfes6Eo_StgLgpZEy3EUU0,2559
-mm_eth/cli/cmd/solc_cmd.py,sha256=HDLThGAxk8MlJh_OBTsivoXYCKDlGnljRFp-BbYDlU0,714
-mm_eth/cli/cmd/transfer_cmd.py,sha256=kKNoU_kNl2blz9ydbvhlEY1Kck0fCMv4RKwU84HyOSw,16933
-mm_eth/cli/cmd/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_eth/cli/cmd/wallet/mnemonic_cmd.py,sha256=xE-5Ux9BdYsTZYBy0dMn9jupGhW4ced-AgYscy_wU_4,1007
-mm_eth/cli/cmd/wallet/private_key_cmd.py,sha256=wuW_LvmIZiT9T4R8ir0wH1VQ_CEPjmrLgS-vzf0yv70,272
-mm_eth-0.6.2.dist-info/METADATA,sha256=etjH_lZpyb7tlF0LawFlfKZ7EhCGuiE9rFj2y6QXzyE,275
-mm_eth-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_eth-0.6.2.dist-info/entry_points.txt,sha256=aGhpsozl8NIrkuUcX5fSgURCcDhr3ShUdeTSIrJq4oc,46
-mm_eth-0.6.2.dist-info/RECORD,,