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

mm_eth/cli/cmd/balances_cmd.py

@@ -1,15 +1,14 @@
 from dataclasses import dataclass
 from typing import Annotated
 
-from mm_std import BaseConfig, Err, Ok, fatal
+from mm_std import BaseConfig, fatal
 from pydantic import BeforeValidator
 from rich.live import Live
 from rich.table import Table
 
-from mm_eth import erc20, rpc
+from mm_eth import converters, retry
 from mm_eth.cli.cli_utils import BaseConfigParams
 from mm_eth.cli.validators import Validators
-from mm_eth.utils import from_token_wei_str, from_wei_str
 
 
 class Config(BaseConfig):
@@ -31,12 +30,12 @@ class BalancesCmdParams(BaseConfigParams):
     show_nonce: bool
 
 
-def run(params: BalancesCmdParams) -> None:
+async def run(params: BalancesCmdParams) -> None:
     config = Config.read_toml_config_or_exit(params.config_path)
     if params.print_config:
         config.print_and_exit()
 
-    tokens = _get_tokens_info(config)
+    tokens = await _get_tokens_info(config)
 
     table = Table(title="balances")
     table.add_column("address")
@@ -52,36 +51,33 @@ def run(params: BalancesCmdParams) -> None:
         for address in config.addresses:
             row = [address]
             if params.show_nonce:
-                row.append(str(rpc.eth_get_transaction_count(config.nodes, address, attempts=5).ok_or_err()))
+                nonce = await retry.eth_get_transaction_count(5, config.nodes, None, address=address)
+                row.append(str(nonce.value_or_error()))
 
-            base_balance_res = rpc.eth_get_balance(config.nodes, address, attempts=5)
-            if isinstance(base_balance_res, Ok):
-                base_sum += base_balance_res.ok
+            base_balance_res = await retry.eth_get_balance(5, config.nodes, None, address=address)
+            if base_balance_res.is_ok():
+                balance = base_balance_res.unwrap()
+                base_sum += balance
                 if params.wei:
-                    row.append(str(base_balance_res.ok))
+                    row.append(str(balance))
                 else:
-                    row.append(
-                        from_wei_str(base_balance_res.ok, "eth", round_ndigits=config.round_ndigits, print_unit_name=False),
-                    )
+                    row.append(str(converters.from_wei(balance, "eth", round_ndigits=config.round_ndigits)))
             else:
-                row.append(base_balance_res.err)
+                row.append(base_balance_res.unwrap_error())
 
             for t in tokens:
-                token_balance_res = erc20.get_balance(config.nodes, t.address, address, attempts=5)
-                if isinstance(token_balance_res, Ok):
-                    token_sum[t.address] += token_balance_res.ok
+                token_balance_res = await retry.erc20_balance(5, config.nodes, None, token=t.address, wallet=address)
+                if token_balance_res.is_ok():
+                    token_balance = token_balance_res.unwrap()
+                    token_sum[t.address] += token_balance
                     if params.wei:
-                        row.append(str(token_balance_res.ok))
+                        row.append(str(token_balance))
                     else:
                         row.append(
-                            from_token_wei_str(
-                                token_balance_res.ok,
-                                decimals=t.decimals,
-                                round_ndigits=config.round_ndigits,
-                            ),
+                            str(converters.from_wei(token_balance, "t", round_ndigits=config.round_ndigits, decimals=t.decimals))
                         )
                 else:
-                    row.append(token_balance_res.err)
+                    row.append(token_balance_res.unwrap_error())
 
             table.add_row(*row)
 
@@ -92,26 +88,29 @@ def run(params: BalancesCmdParams) -> None:
             sum_row.append(str(base_sum))
             sum_row.extend([str(token_sum[t.address]) for t in tokens])
         else:
-            sum_row.append(from_wei_str(base_sum, "eth", round_ndigits=config.round_ndigits, print_unit_name=False))
+            sum_row.append(str(converters.from_wei(base_sum, "eth", round_ndigits=config.round_ndigits)))
             sum_row.extend(
-                [from_token_wei_str(token_sum[t.address], t.decimals, round_ndigits=config.round_ndigits) for t in tokens]
+                [
+                    str(converters.from_wei(token_sum[t.address], "t", round_ndigits=config.round_ndigits, decimals=t.decimals))
+                    for t in tokens
+                ]
             )
 
         table.add_row(*sum_row)
 
 
-def _get_tokens_info(config: Config) -> list[Token]:
+async def _get_tokens_info(config: Config) -> list[Token]:
     result: list[Token] = []
     for address in config.tokens:
-        decimals_res = erc20.get_decimals(config.nodes, address, attempts=5)
-        if isinstance(decimals_res, Err):
-            fatal(f"can't get token {address} decimals: {decimals_res.err}")
-        decimal = decimals_res.ok
-
-        symbols_res = erc20.get_symbol(config.nodes, address, attempts=5)
-        if isinstance(symbols_res, Err):
-            fatal(f"can't get token {address} symbol: {symbols_res.err}")
-        symbol = symbols_res.ok
+        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()}")
+        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()}")
+        symbol = symbols_res.unwrap()
 
         result.append(Token(address=address, decimals=decimal, symbol=symbol))
 

mm_eth/cli/cmd/deploy_cmd.py

@@ -1,9 +1,8 @@
 import yaml
-from mm_std import BaseConfig, fatal
+from mm_std import BaseConfig
 from pydantic import StrictStr
 
-from mm_eth import account, deploy
-from mm_eth.cli import rpc_helpers
+from mm_eth import account, deploy, retry
 from mm_eth.cli.cli_utils import BaseConfigParams
 
 
@@ -22,10 +21,10 @@ class Config(BaseConfig):
 
 
 class DeployCmdParams(BaseConfigParams):
-    pass
+    broadcast: bool = False
 
 
-def run(cli_params: DeployCmdParams) -> None:
+async def run(cli_params: DeployCmdParams) -> None:
     config = Config.read_toml_config_or_exit(cli_params.config_path)
     if cli_params.print_config:
         config.print_and_exit({"private_key"})
@@ -33,12 +32,11 @@ def run(cli_params: DeployCmdParams) -> None:
     constructor_types = yaml.full_load(config.constructor_types)
     constructor_values = yaml.full_load(config.constructor_values)
 
-    sender_address = account.private_to_address(config.private_key)
-    if sender_address is None:
-        fatal("private address is wrong")
+    sender_address = account.private_to_address(config.private_key).unwrap()
 
-    nonce = rpc_helpers.get_nonce(config.node, sender_address)
-    if nonce is None:
-        fatal("can't get nonce")
+    if config.nonce is None:
+        config.nonce = (await retry.eth_get_transaction_count(5, config.node, None, address=sender_address)).unwrap(
+            "can't get nonce"
+        )
 
     deploy.get_deploy_contract_data(config.contract_bin, constructor_types, constructor_values)

mm_eth/cli/cmd/node_cmd.py

@@ -1,11 +1,13 @@
+from decimal import Decimal
+
+import eth_utils
 import pydash
-from mm_std import Ok, PrintFormat, print_json
+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
-from mm_eth.utils import from_wei_str, name_network
+from mm_eth import rpc, utils
 
 
 class NodeInfo(BaseModel):
@@ -13,7 +15,7 @@ class NodeInfo(BaseModel):
     chain_id: int | str
     chain_name: str
     block_number: int | str
-    base_fee: str
+    base_fee: str | int | Decimal
 
     def table_row(self) -> list[object]:
         return [self.url, self.chain_id, self.chain_name, self.block_number, self.base_fee]
@@ -40,7 +42,7 @@ class LiveTable:
         self.live.stop()
 
 
-def run(urls: list[str], proxy: str | None, print_format: PrintFormat) -> None:
+async def run(urls: list[str], proxy: str | None, print_format: PrintFormat) -> None:
     urls = pydash.uniq(urls)
     result = []
     live_table = LiveTable(
@@ -48,7 +50,7 @@ def run(urls: list[str], proxy: str | None, print_format: PrintFormat) -> None:
         ignore=print_format != PrintFormat.TABLE,
     )
     for url in urls:
-        node_info = _get_node_info(url, proxy)
+        node_info = await _get_node_info(url, proxy)
         live_table.add_row(*node_info.table_row())
         result.append(node_info)
 
@@ -64,15 +66,18 @@ def run(urls: list[str], proxy: str | None, print_format: PrintFormat) -> None:
     #         table.add_row(url, str(chain_id), chain_name, str(block_number), base_fee)
 
 
-def _get_node_info(url: str, proxy: str | None) -> NodeInfo:
-    chain_id_res = rpc.eth_chain_id(url, timeout=10, proxies=proxy)
-    chain_id = chain_id_res.ok_or_err()
+async def _get_node_info(url: str, proxy: str | None) -> NodeInfo:
+    chain_id_res = await rpc.eth_chain_id(url, proxy=proxy)
+    chain_id = chain_id_res.value_or_error()
     chain_name = ""
-    if isinstance(chain_id_res, Ok):
-        chain_name = name_network(chain_id_res.ok)
-    block_number = rpc.eth_block_number(url, timeout=10, proxies=proxy).ok_or_err()
-    base_fee = rpc.get_base_fee_per_gas(url, timeout=10, proxies=proxy).map_or_else(
-        lambda err: err,
-        lambda ok: from_wei_str(ok, "gwei"),
+    if chain_id_res.is_ok():
+        chain_name = utils.name_network(chain_id_res.unwrap())
+    block_number = (await rpc.eth_block_number(url, proxy=proxy)).value_or_error()
+    base_fee = (
+        (await rpc.get_base_fee_per_gas(url, proxy=proxy))
+        .map(
+            lambda ok: eth_utils.from_wei(ok, "gwei"),
+        )
+        .value_or_error()
     )
     return NodeInfo(url=url, chain_id=chain_id, chain_name=chain_name, block_number=block_number, base_fee=base_fee)

mm_eth/cli/cmd/solc_cmd.py

@@ -1,19 +1,20 @@
 import json
+from pathlib import Path
 
-from mm_std import Err, PrintFormat, fatal, print_json, print_plain
+from mm_std import PrintFormat, fatal, print_json, print_plain
 from mm_std.fs import get_filename_without_extension
 
 from mm_eth.solc import solc
 
 
-def run(contract_path: str, tmp_dir: str, print_format: PrintFormat) -> None:
+def run(contract_path: Path, tmp_dir: Path, print_format: PrintFormat) -> None:
     contract_name = get_filename_without_extension(contract_path)
     res = solc(contract_name, contract_path, tmp_dir)
-    if isinstance(res, Err):
-        fatal(res.err)
+    if res.is_err():
+        fatal(res.unwrap_error())
 
-    bin_ = res.ok.bin
-    abi = res.ok.abi
+    bin_ = res.unwrap().bin
+    abi = res.unwrap().abi
 
     if print_format == PrintFormat.JSON:
         print_json({"bin": bin_, "abi": json.loads(abi)})