mm-balance 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

mm_balance/{workers.py → balance_fetcher.py}

@@ -1,13 +1,13 @@
 from dataclasses import dataclass
 from decimal import Decimal
 
-from mm_std import ConcurrentTasks, PrintFormat, Result
+from mm_std import AsyncTaskRunner, PrintFormat, Result
 from rich.progress import TaskID
 
+from mm_balance import rpc
 from mm_balance.config import Config
-from mm_balance.constants import NETWORK_APTOS, NETWORK_BITCOIN, NETWORK_SOLANA, Network
+from mm_balance.constants import Network
 from mm_balance.output import utils
-from mm_balance.rpc import aptos, btc, evm, solana
 from mm_balance.token_decimals import TokenDecimals
 
 
@@ -19,7 +19,7 @@ class Task:
     balance: Result[Decimal] | None = None
 
 
-class Workers:
+class BalanceFetcher:
     def __init__(self, config: Config, token_decimals: TokenDecimals) -> None:
         self.config = config
         self.token_decimals = token_decimals
@@ -35,15 +35,14 @@ class Workers:
             if self.tasks[network]:
                 self.progress_bar_task[network] = utils.create_progress_task(self.progress_bar, network, len(self.tasks[network]))
 
-    def process(self) -> None:
+    async def process(self) -> None:
         with self.progress_bar:
-            job = ConcurrentTasks(max_workers=10)
+            runner = AsyncTaskRunner(max_concurrent_tasks=10)
             for network in self.config.networks():
-                job.add_task(network, self._process_network, args=(network,))
-            job.execute()
+                runner.add_task(f"process_{network}", self._process_network(network))
+            await runner.run()
 
     def get_group_tasks(self, group_index: int, network: Network) -> list[Task]:
-        # TODO: can we get network by group_index?
         return [b for b in self.tasks[network] if b.group_index == group_index]
 
     def get_errors(self) -> list[Task]:
@@ -52,31 +51,25 @@ class Workers:
             result.extend([task for task in self.tasks[network] if task.balance is not None and task.balance.is_err()])
         return result
 
-    def _process_network(self, network: Network) -> None:
-        job = ConcurrentTasks(max_workers=self.config.workers[network])
+    async def _process_network(self, network: Network) -> None:
+        runner = AsyncTaskRunner(max_concurrent_tasks=self.config.workers[network])
         for idx, task in enumerate(self.tasks[network]):
-            job.add_task(str(idx), self._get_balance, args=(network, task.wallet_address, task.token_address))
-        job.execute()
+            runner.add_task(str(idx), self._get_balance(network, task.wallet_address, task.token_address))
+        res = await runner.run()
+
         # TODO: print job.exceptions if present
         for idx, _task in enumerate(self.tasks[network]):
-            self.tasks[network][idx].balance = job.result.get(str(idx))  # type: ignore[assignment]
-
-    def _get_balance(self, network: Network, wallet_address: str, token_address: str | None) -> Result[Decimal]:
-        nodes = self.config.nodes[network]
-        round_ndigits = self.config.settings.round_ndigits
-        proxies = self.config.settings.proxies
-        token_decimals = self.token_decimals[network][token_address]
-
-        if network.is_evm_network():
-            res = evm.get_balance(nodes, wallet_address, token_address, token_decimals, proxies, round_ndigits)
-        elif network == NETWORK_BITCOIN:
-            res = btc.get_balance(wallet_address, proxies, round_ndigits)
-        elif network == NETWORK_APTOS:
-            res = aptos.get_balance(nodes, wallet_address, token_address, token_decimals, proxies, round_ndigits)
-        elif network == NETWORK_SOLANA:
-            res = solana.get_balance(nodes, wallet_address, token_address, token_decimals, proxies, round_ndigits)
-        else:
-            raise ValueError(f"Unsupported network: {network}")
+            self.tasks[network][idx].balance = res.results.get(str(idx))
 
+    async def _get_balance(self, network: Network, wallet_address: str, token_address: str | None) -> Result[Decimal]:
+        res = await rpc.get_balance(
+            network=network,
+            nodes=self.config.nodes[network],
+            proxies=self.config.settings.proxies,
+            wallet_address=wallet_address,
+            token_address=token_address,
+            token_decimals=self.token_decimals[network][token_address],
+            ndigits=self.config.settings.round_ndigits,
+        )
         self.progress_bar.update(self.progress_bar_task[network], advance=1)
         return res

mm_balance/cli.py

@@ -1,4 +1,4 @@
-import getpass
+import asyncio
 import importlib.metadata
 import pkgutil
 from pathlib import Path
@@ -7,14 +7,9 @@ from typing import Annotated
 import typer
 from mm_std import PrintFormat, fatal, pretty_print_toml
 
-from mm_balance.config import Config
+from mm_balance import command_runner
+from mm_balance.command_runner import CommandParameters
 from mm_balance.constants import NETWORKS
-from mm_balance.diff import BalancesDict, Diff
-from mm_balance.output.formats import json_format, table_format
-from mm_balance.price import Prices, get_prices
-from mm_balance.result import create_balances_result
-from mm_balance.token_decimals import get_token_decimals
-from mm_balance.workers import Workers
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
@@ -49,63 +44,28 @@ def cli(
     debug: Annotated[bool | None, typer.Option("--debug", "-d", help="Print debug info.")] = None,
     print_config: Annotated[bool | None, typer.Option("--config", "-c", help="Print config and exit.")] = None,
     price: Annotated[bool | None, typer.Option("--price/--no-price", help="Print prices.")] = None,
-    save_balances_file: Annotated[Path | None, typer.Option("--save-balances-file", help="Save balances file.")] = None,
-    diff_from_balances_file: Annotated[
-        Path | None, typer.Option("--diff-from-balances-file", help="Diff from balances file.")
-    ] = None,
+    save_balances: Annotated[Path | None, typer.Option("--save-balances", help="Save balances file.")] = None,
+    diff_from_balances: Annotated[Path | None, typer.Option("--diff-from-balances", help="Diff from balances file.")] = None,
     _example: Annotated[bool | None, typer.Option("--example", callback=example_callback, help="Print a config example.")] = None,
     _networks: Annotated[
         bool | None, typer.Option("--networks", callback=networks_callback, help="Print supported networks.")
     ] = None,
     _version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=True),
 ) -> None:
-    zip_password = ""  # nosec
-    if config_path.name.endswith(".zip"):
-        zip_password = getpass.getpass("zip password")
-    config = Config.read_toml_config_or_exit(config_path, zip_password=zip_password)
-    if print_config:
-        config.print_and_exit()
-
-    if print_format is not None:
-        config.settings.print_format = print_format
-    if debug is not None:
-        config.settings.print_debug = debug
-    if skip_empty is not None:
-        config.settings.skip_empty = skip_empty
-    if price is not None:
-        config.settings.price = price
-
-    if config.settings.print_debug and config.settings.print_format is PrintFormat.TABLE:
-        table_format.print_nodes(config)
-        table_format.print_proxy_count(config)
-
-    token_decimals = get_token_decimals(config)
-    if config.settings.print_debug and config.settings.print_format is PrintFormat.TABLE:
-        table_format.print_token_decimals(token_decimals)
-
-    prices = get_prices(config) if config.settings.price else Prices()
-    if config.settings.print_format is PrintFormat.TABLE:
-        table_format.print_prices(config, prices)
-
-    workers = Workers(config, token_decimals)
-    workers.process()
-
-    result = create_balances_result(config, prices, workers)
-    if config.settings.print_format is PrintFormat.TABLE:
-        table_format.print_result(config, result, workers)
-    elif config.settings.print_format is PrintFormat.JSON:
-        json_format.print_result(config, token_decimals, prices, workers, result)
-    else:
-        fatal("Unsupported print format")
-
-    if save_balances_file:
-        BalancesDict.from_balances_result(result).save_to_path(save_balances_file)
-
-    if diff_from_balances_file:
-        old_balances = BalancesDict.from_file(diff_from_balances_file)
-        new_balances = BalancesDict.from_balances_result(result)
-        diff = Diff.calc(old_balances, new_balances)
-        diff.print(config.settings.print_format)
+    asyncio.run(
+        command_runner.run(
+            CommandParameters(
+                config_path=config_path,
+                print_format=print_format,
+                skip_empty=skip_empty,
+                debug=debug,
+                print_config=print_config,
+                price=price,
+                save_balances=save_balances,
+                diff_from_balances=diff_from_balances,
+            )
+        )
+    )
 
 
 if __name__ == "__main__":

mm_balance/command_runner.py

@@ -0,0 +1,74 @@
+import getpass
+from pathlib import Path
+
+from mm_std import PrintFormat, fatal
+from pydantic import BaseModel
+
+from mm_balance.balance_fetcher import BalanceFetcher
+from mm_balance.config import Config
+from mm_balance.diff import BalancesDict, Diff
+from mm_balance.output.formats import json_format, table_format
+from mm_balance.price import Prices, get_prices
+from mm_balance.result import create_balances_result
+from mm_balance.token_decimals import get_token_decimals
+
+
+class CommandParameters(BaseModel):
+    config_path: Path
+    print_format: PrintFormat | None
+    skip_empty: bool | None
+    debug: bool | None
+    print_config: bool | None
+    price: bool | None
+    save_balances: Path | None
+    diff_from_balances: Path | None
+
+
+async def run(params: CommandParameters) -> None:
+    zip_password = ""  # nosec
+    if params.config_path.name.endswith(".zip"):
+        zip_password = getpass.getpass("zip password")
+    config = Config.read_toml_config_or_exit(params.config_path, zip_password=zip_password)
+    if params.print_config:
+        config.print_and_exit()
+
+    if params.print_format is not None:
+        config.settings.print_format = params.print_format
+    if params.debug is not None:
+        config.settings.print_debug = params.debug
+    if params.skip_empty is not None:
+        config.settings.skip_empty = params.skip_empty
+    if params.price is not None:
+        config.settings.price = params.price
+
+    if config.settings.print_debug and config.settings.print_format is PrintFormat.TABLE:
+        table_format.print_nodes(config)
+        table_format.print_proxy_count(config)
+
+    token_decimals = await get_token_decimals(config)
+    if config.settings.print_debug and config.settings.print_format is PrintFormat.TABLE:
+        table_format.print_token_decimals(token_decimals)
+
+    prices = await get_prices(config) if config.settings.price else Prices()
+    if config.settings.print_format is PrintFormat.TABLE:
+        table_format.print_prices(config, prices)
+
+    workers = BalanceFetcher(config, token_decimals)
+    await workers.process()
+
+    result = create_balances_result(config, prices, workers)
+    if config.settings.print_format is PrintFormat.TABLE:
+        table_format.print_result(config, result, workers)
+    elif config.settings.print_format is PrintFormat.JSON:
+        json_format.print_result(config, token_decimals, prices, workers, result)
+    else:
+        fatal("Unsupported print format")
+
+    if params.save_balances:
+        BalancesDict.from_balances_result(result).save_to_path(params.save_balances)
+
+    if params.diff_from_balances:
+        old_balances = BalancesDict.from_file(params.diff_from_balances)
+        new_balances = BalancesDict.from_balances_result(result)
+        diff = Diff.calc(old_balances, new_balances)
+        diff.print(config.settings.print_format)

mm_balance/config.py

@@ -16,11 +16,18 @@ class Validators(ConfigValidators):
     pass
 
 
-class Group(BaseConfig):
+class AssetGroup(BaseConfig):
+    """
+    Represents a group of cryptocurrency assets of the same type.
+
+    An asset group contains information about a specific cryptocurrency (token)
+    across multiple addresses/wallets.
+    """
+
     comment: str = ""
     ticker: Annotated[str, StringConstraints(to_upper=True)]
     network: Network
-    token: str | None = None  # Token address. If None, it's a native token, for example ETH
+    token: str | None = None  # Token address. If None, it's a native token
     decimals: int | None = None
     coingecko_id: str | None = None
     addresses: Annotated[list[str], BeforeValidator(Validators.addresses(unique=True))]
@@ -42,7 +49,7 @@ class Group(BaseConfig):
             self.token = self.token.lower()
         return self
 
-    def process_addresses(self, address_groups: list[AddressGroup]) -> None:
+    def process_addresses(self, address_groups: list[AddressCollection]) -> None:
         result = []
         for line in self.addresses:
             if line.startswith("file:"):
@@ -60,10 +67,12 @@ class Group(BaseConfig):
             else:
                 result.append(line)
         # TODO: check address is valid. There is network info in the group
+        if self.network.need_lowercase_address():
+            result = [address.lower() for address in result]
         self.addresses = pydash.uniq(result)
 
 
-class AddressGroup(BaseConfig):
+class AddressCollection(BaseConfig):
     name: str
     addresses: Annotated[list[str], BeforeValidator(ConfigValidators.addresses(unique=True))]
 
@@ -79,8 +88,8 @@ class Settings(BaseConfig):
 
 
 class Config(BaseConfig):
-    groups: list[Group] = Field(alias="coins")
-    addresses: list[AddressGroup] = Field(default_factory=list)
+    groups: list[AssetGroup] = Field(alias="coins")
+    addresses: list[AddressCollection] = Field(default_factory=list)
     nodes: dict[Network, list[str]] = Field(default_factory=dict)
     workers: dict[Network, int] = Field(default_factory=dict)
     settings: Settings = Field(default_factory=Settings)  # type: ignore[arg-type]

mm_balance/constants.py

@@ -12,7 +12,10 @@ class Network(str):
     __slots__ = ()
 
     def is_evm_network(self) -> bool:
-        return self in [NETWORK_ETHEREUM, NETWORK_ARBITRUM_ONE, NETWORK_OP_MAINNET] or self.startswith("evm-")
+        return self in EVM_NETWORKS or self.startswith("evm-")
+
+    def need_lowercase_address(self) -> bool:
+        return self.is_evm_network()
 
     @classmethod
     def __get_pydantic_core_schema__(cls, _source_type: object, handler: GetCoreSchemaHandler) -> CoreSchema:
@@ -26,6 +29,7 @@ NETWORK_ETHEREUM = Network("ethereum")
 NETWORK_SOLANA = Network("solana")
 NETWORK_OP_MAINNET = Network("op-mainnet")
 NETWORKS = [NETWORK_APTOS, NETWORK_ARBITRUM_ONE, NETWORK_BITCOIN, NETWORK_ETHEREUM, NETWORK_SOLANA, NETWORK_OP_MAINNET]
+EVM_NETWORKS = [NETWORK_ETHEREUM, NETWORK_ARBITRUM_ONE, NETWORK_OP_MAINNET]
 
 
 TOKEN_ADDRESS: dict[Network, dict[str, str]] = {

mm_balance/output/formats/json_format.py

@@ -1,13 +1,15 @@
 from mm_std import print_json
 
+from mm_balance.balance_fetcher import BalanceFetcher
 from mm_balance.config import Config
 from mm_balance.price import Prices
 from mm_balance.result import BalancesResult
 from mm_balance.token_decimals import TokenDecimals
-from mm_balance.workers import Workers
 
 
-def print_result(config: Config, token_decimals: TokenDecimals, prices: Prices, workers: Workers, result: BalancesResult) -> None:
+def print_result(
+    config: Config, token_decimals: TokenDecimals, prices: Prices, workers: BalanceFetcher, result: BalancesResult
+) -> None:
     data: dict[str, object] = {}
     if config.settings.print_debug:
         data["nodes"] = config.nodes

mm_balance/output/formats/table_format.py

@@ -2,12 +2,12 @@ from decimal import Decimal
 
 from mm_std import print_table
 
+from mm_balance.balance_fetcher import BalanceFetcher
 from mm_balance.config import Config
 from mm_balance.output.utils import format_number
 from mm_balance.price import Prices
 from mm_balance.result import BalancesResult, GroupResult, Total
 from mm_balance.token_decimals import TokenDecimals
-from mm_balance.workers import Workers
 
 
 def print_nodes(config: Config) -> None:
@@ -38,7 +38,7 @@ def print_prices(config: Config, prices: Prices) -> None:
         print_table("Prices", ["coin", "usd"], rows)
 
 
-def print_result(config: Config, result: BalancesResult, workers: Workers) -> None:
+def print_result(config: Config, result: BalancesResult, workers: BalanceFetcher) -> None:
     for group in result.groups:
         _print_group(config, group)
 
@@ -49,14 +49,14 @@ def print_result(config: Config, result: BalancesResult, workers: Workers) -> No
     _print_errors(config, workers)
 
 
-def _print_errors(config: Config, workers: Workers) -> None:
+def _print_errors(config: Config, workers: BalanceFetcher) -> None:
     error_tasks = workers.get_errors()
     if not error_tasks:
         return
     rows = []
     for task in error_tasks:
         group = config.groups[task.group_index]
-        rows.append([group.ticker + " / " + group.network, task.wallet_address, task.balance.err])  # type: ignore[union-attr]
+        rows.append([group.ticker + " / " + group.network, task.wallet_address, task.balance.error])  # type: ignore[union-attr]
     print_table("Errors", ["coin", "address", "error"], rows)
 
 

mm_balance/price.py

@@ -2,10 +2,9 @@ from collections import defaultdict
 from decimal import Decimal
 
 import pydash
-from mm_std import hr
-from mm_std.random_ import random_str_choice
+from mm_std import http_request, random_str_choice
 
-from mm_balance.config import Config, Group
+from mm_balance.config import AssetGroup, Config
 from mm_balance.constants import RETRIES_COINGECKO_PRICES, TICKER_TO_COINGECKO_ID
 
 
@@ -18,7 +17,7 @@ class Prices(defaultdict[str, Decimal]):
     """
 
 
-def get_prices(config: Config) -> Prices:
+async def get_prices(config: Config) -> Prices:
     result = Prices()
 
     coingecko_map: dict[str, str] = {}  # ticker -> coingecko_id
@@ -30,19 +29,21 @@ def get_prices(config: Config) -> Prices:
 
     url = f"https://api.coingecko.com/api/v3/simple/price?ids={','.join(coingecko_map.values())}&vs_currencies=usd"
     for _ in range(RETRIES_COINGECKO_PRICES):
-        res = hr(url, proxy=random_str_choice(config.settings.proxies))
-        if res.code != 200:
+        res = await http_request(url, proxy=random_str_choice(config.settings.proxies))
+        if res.status_code != 200:
             continue
 
+        json_body = res.parse_json_body() or {}
+
         for ticker, coingecko_id in coingecko_map.items():
-            if coingecko_id in res.json:
-                result[ticker] = Decimal(str(pydash.get(res.json, f"{coingecko_id}.usd")))
+            if coingecko_id in json_body:
+                result[ticker] = Decimal(str(pydash.get(json_body, f"{coingecko_id}.usd")))
         break
 
     return result
 
 
-def get_coingecko_id(group: Group) -> str | None:
+def get_coingecko_id(group: AssetGroup) -> str | None:
     if group.coingecko_id:
         return group.coingecko_id
     return TICKER_TO_COINGECKO_ID.get(group.ticker)

mm_balance/result.py

@@ -2,13 +2,11 @@ from collections import defaultdict
 from dataclasses import dataclass
 from decimal import Decimal
 
-from mm_std import Ok
-
-from mm_balance.config import Config, Group
+from mm_balance.balance_fetcher import BalanceFetcher, Task
+from mm_balance.config import AssetGroup, Config
 from mm_balance.constants import USD_STABLECOINS, Network
 from mm_balance.price import Prices
 from mm_balance.utils import round_decimal
-from mm_balance.workers import Task, Workers
 
 
 @dataclass
@@ -52,7 +50,7 @@ class BalancesResult:
     total_share: Total
 
 
-def create_balances_result(config: Config, prices: Prices, workers: Workers) -> BalancesResult:
+def create_balances_result(config: Config, prices: Prices, workers: BalanceFetcher) -> BalancesResult:
     groups = []
     for group_index, group in enumerate(config.groups):
         tasks = workers.get_group_tasks(group_index, group.network)
@@ -63,19 +61,6 @@ def create_balances_result(config: Config, prices: Prices, workers: Workers) ->
     return BalancesResult(groups=groups, total=total, total_share=total_share)
 
 
-# def save_balances_file(result: BalancesResult, balances_file: Path) -> None:
-#     data = {}
-#     for group in result.groups:
-#         if group.network not in data:
-#             data[group.network] = {}
-#         if group.ticker not in data[group.network]:
-#             data[group.network][group.ticker] = {}
-#         for address in group.addresses:
-#             if isinstance(address.balance, Balance):
-#                 data[group.network][group.ticker][address.address] = float(address.balance.balance)
-#     json.dump(data, balances_file.open("w"), indent=2)
-
-
 def _create_total(use_share: bool, groups: list[GroupResult]) -> Total:
     coin_balances: dict[str, Decimal] = defaultdict(Decimal)  # ticker -> balance
     coin_usd_values: dict[str, Decimal] = defaultdict(Decimal)  # ticker -> usd value
@@ -108,7 +93,7 @@ def _create_total(use_share: bool, groups: list[GroupResult]) -> Total:
     )
 
 
-def _create_group_result(config: Config, group: Group, tasks: list[Task], prices: Prices) -> GroupResult:
+def _create_group_result(config: Config, group: AssetGroup, tasks: list[Task], prices: Prices) -> GroupResult:
     addresses = []
     balance_sum = Decimal(0)
     usd_sum = Decimal(0)
@@ -116,8 +101,8 @@ def _create_group_result(config: Config, group: Group, tasks: list[Task], prices
         balance: Balance | str
         if task.balance is None:
             balance = "balance is None! Something went wrong."
-        elif isinstance(task.balance, Ok):
-            coin_value = task.balance.ok
+        elif task.balance.is_ok():
+            coin_value = task.balance.unwrap()
             usd_value = Decimal(0)
             if group.ticker in prices:
                 usd_value = round_decimal(coin_value * prices[group.ticker], config.settings.round_ndigits)
@@ -125,7 +110,7 @@ def _create_group_result(config: Config, group: Group, tasks: list[Task], prices
             balance_sum += balance.balance
             usd_sum += balance.usd_value
         else:
-            balance = task.balance.err
+            balance = task.balance.unwrap_error()
         addresses.append(AddressBalance(address=task.wallet_address, balance=balance))
 
     balance_sum_share = balance_sum * group.share
@@ -142,3 +127,16 @@ def _create_group_result(config: Config, group: Group, tasks: list[Task], prices
         balance_sum_share=balance_sum_share,
         usd_sum_share=usd_sum_share,
     )
+
+
+# def save_balances_file(result: BalancesResult, balances_file: Path) -> None:
+#     data = {}
+#     for group in result.groups:
+#         if group.network not in data:
+#             data[group.network] = {}
+#         if group.ticker not in data[group.network]:
+#             data[group.network][group.ticker] = {}
+#         for address in group.addresses:
+#             if isinstance(address.balance, Balance):
+#                 data[group.network][group.ticker][address.address] = float(address.balance.balance)
+#     json.dump(data, balances_file.open("w"), indent=2)

mm_balance/rpc.py

@@ -0,0 +1,183 @@
+from decimal import Decimal
+
+from mm_apt import retry as apt_retry
+from mm_btc.blockstream import BlockstreamClient
+from mm_crypto_utils import Nodes, Proxies
+from mm_eth import retry as eth_retry
+from mm_sol import retry as sol_retry
+from mm_std import Result
+
+from mm_balance.constants import (
+    NETWORK_APTOS,
+    NETWORK_BITCOIN,
+    NETWORK_SOLANA,
+    RETRIES_BALANCE,
+    RETRIES_DECIMALS,
+    TIMEOUT_BALANCE,
+    TIMEOUT_DECIMALS,
+    Network,
+)
+from mm_balance.utils import scale_and_round
+
+
+async def get_balance(
+    *,
+    network: Network,
+    nodes: Nodes,
+    proxies: Proxies,
+    wallet_address: str,
+    token_address: str | None,
+    token_decimals: int,
+    ndigits: int,
+) -> Result[Decimal]:
+    """
+    Fetch balance for a wallet on specified network.
+
+    This function retrieves the balance of a wallet address on a given network.
+    It supports multiple networks including EVM-compatible chains (Ethereum,
+    Arbitrum, etc.), Bitcoin, Aptos, and Solana. For EVM networks and Solana,
+    it can fetch both native coin and token balances.
+
+    Args:
+        network: The blockchain network to query
+        nodes: RPC nodes to use for the request
+        proxies: Proxy configuration for the request
+        wallet_address: The address of the wallet to check
+        token_address: The address of the token (None for native coin)
+        token_decimals: Number of decimal places for the token
+        ndigits: Number of digits to round the result to
+
+    Returns:
+        Result containing the balance as a Decimal on success, or an error message
+    """
+    if network.is_evm_network():
+        return await _get_evm_balance(
+            nodes=nodes,
+            proxies=proxies,
+            wallet_address=wallet_address,
+            token_address=token_address,
+            token_decimals=token_decimals,
+            ndigits=ndigits,
+        )
+    if network == NETWORK_BITCOIN:
+        return await _get_bitcoin_balance(
+            proxies=proxies,
+            wallet_address=wallet_address,
+            token_decimals=token_decimals,
+            ndigits=ndigits,
+        )
+    if network == NETWORK_APTOS:
+        return await _get_aptos_balance(
+            nodes=nodes,
+            proxies=proxies,
+            wallet_address=wallet_address,
+            token_address=token_address,
+            token_decimals=token_decimals,
+            ndigits=ndigits,
+        )
+    if network == NETWORK_SOLANA:
+        return await _get_solana_balance(
+            nodes=nodes,
+            proxies=proxies,
+            wallet_address=wallet_address,
+            token_address=token_address,
+            token_decimals=token_decimals,
+            ndigits=ndigits,
+        )
+    return Result.err("Unsupported network")
+
+
+async def _get_evm_balance(
+    *,
+    nodes: Nodes,
+    proxies: Proxies,
+    wallet_address: str,
+    token_address: str | None,
+    token_decimals: int,
+    ndigits: int,
+) -> Result[Decimal]:
+    """Fetch balance for EVM-compatible networks."""
+    if token_address is None:
+        res = await eth_retry.eth_get_balance(RETRIES_BALANCE, nodes, proxies, address=wallet_address, timeout=TIMEOUT_BALANCE)
+    else:
+        res = await eth_retry.erc20_balance(
+            RETRIES_BALANCE, nodes, proxies, token=token_address, wallet=wallet_address, timeout=TIMEOUT_BALANCE
+        )
+    return res.map(lambda value: scale_and_round(value, token_decimals, ndigits))
+
+
+async def _get_bitcoin_balance(
+    *,
+    proxies: Proxies,
+    wallet_address: str,
+    token_decimals: int,
+    ndigits: int,
+) -> Result[Decimal]:
+    """Fetch balance for Bitcoin network."""
+    res = await BlockstreamClient(proxies=proxies, attempts=RETRIES_BALANCE).get_confirmed_balance(wallet_address)
+    return res.map(lambda value: scale_and_round(value, token_decimals, ndigits))
+
+
+async def _get_aptos_balance(
+    *,
+    nodes: Nodes,
+    proxies: Proxies,
+    wallet_address: str,
+    token_address: str | None,
+    token_decimals: int,
+    ndigits: int,
+) -> Result[Decimal]:
+    """Fetch balance for Aptos network."""
+    actual_token_address = token_address if token_address is not None else "0x1::aptos_coin::AptosCoin"
+    res = await apt_retry.get_balance(
+        RETRIES_BALANCE, nodes, proxies, account=wallet_address, coin_type=actual_token_address, timeout=TIMEOUT_BALANCE
+    )
+    return res.map(lambda value: scale_and_round(value, token_decimals, ndigits))
+
+
+async def _get_solana_balance(
+    *,
+    nodes: Nodes,
+    proxies: Proxies,
+    wallet_address: str,
+    token_address: str | None,
+    token_decimals: int,
+    ndigits: int,
+) -> Result[Decimal]:
+    """Fetch balance for Solana network."""
+    if token_address is None:
+        res = await sol_retry.get_sol_balance(RETRIES_BALANCE, nodes, proxies, address=wallet_address, timeout=TIMEOUT_BALANCE)
+    else:
+        res = await sol_retry.get_token_balance(
+            RETRIES_BALANCE, nodes, proxies, owner=wallet_address, token=token_address, timeout=TIMEOUT_BALANCE
+        )
+    return res.map(lambda value: scale_and_round(value, token_decimals, ndigits))
+
+
+async def get_token_decimals(
+    *,
+    network: Network,
+    nodes: Nodes,
+    proxies: Proxies,
+    token_address: str,
+) -> Result[int]:
+    """
+    Fetch the number of decimal places for a token.
+
+    This function retrieves the decimal precision for a token on a given network.
+    Currently supports EVM-compatible networks and Solana.
+
+    Args:
+        network: The blockchain network the token exists on
+        nodes: RPC nodes to use for the request
+        proxies: Proxy configuration for the request
+        token_address: The address of the token
+
+    Returns:
+        Result containing the number of decimals as an integer on success, or an error message
+    """
+    if network.is_evm_network():
+        return await eth_retry.erc20_decimals(RETRIES_DECIMALS, nodes, proxies, token=token_address, timeout=TIMEOUT_DECIMALS)
+    if network == NETWORK_SOLANA:
+        return await sol_retry.get_token_decimals(RETRIES_DECIMALS, nodes, proxies, token=token_address, timeout=TIMEOUT_DECIMALS)
+    return Result.err("Unsupported network")

mm_balance/token_decimals.py

@@ -1,8 +1,8 @@
-from mm_std import Err, fatal
+from mm_std import fatal
 
+from mm_balance import rpc
 from mm_balance.config import Config
 from mm_balance.constants import NETWORK_APTOS, NETWORK_BITCOIN, NETWORK_SOLANA, Network
-from mm_balance.rpc import evm, solana
 
 
 class TokenDecimals(dict[Network, dict[str | None, int]]):  # {network: {None: 18}} -- None is for native token, ex. ETH
@@ -12,9 +12,8 @@ class TokenDecimals(dict[Network, dict[str | None, int]]):  # {network: {None: 1
             self[network] = {}
 
 
-def get_token_decimals(config: Config) -> TokenDecimals:
+async def get_token_decimals(config: Config) -> TokenDecimals:
     result = TokenDecimals(config.networks())
-    proxies = config.settings.proxies
 
     for group in config.groups:
         # token_decimals is already known
@@ -39,15 +38,12 @@ def get_token_decimals(config: Config) -> TokenDecimals:
         if group.token in result[group.network]:
             continue  # don't request for a token_decimals twice
 
-        nodes = config.nodes[group.network]
-        if group.network.is_evm_network():
-            res = evm.get_token_decimals(nodes, group.token, proxies)
-        elif group.network == NETWORK_SOLANA:
-            res = solana.get_token_decimals(nodes, group.token, proxies)
-        else:
-            fatal(f"unsupported network: {group.network}. Cant get token decimals for {group.token}")
-        if isinstance(res, Err):
-            fatal(f"can't get decimals for token {group.ticker} / {group.token}, error={res.err}")
-        result[group.network][group.token] = res.ok
+        res = await rpc.get_token_decimals(
+            network=group.network, nodes=config.nodes[group.network], proxies=config.settings.proxies, token_address=group.token
+        )
+
+        if res.is_err():
+            fatal(f"can't get decimals for token {group.ticker} / {group.token}, error={res.unwrap_error()}")
+        result[group.network][group.token] = res.unwrap()
 
     return result

mm_balance-0.4.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: mm-balance
+Version: 0.4.0
+Requires-Python: >=3.12
+Requires-Dist: deepdiff==8.4.2
+Requires-Dist: mm-apt==0.3.4
+Requires-Dist: mm-btc==0.4.2
+Requires-Dist: mm-eth==0.6.1
+Requires-Dist: mm-sol==0.6.2
+Requires-Dist: typer==0.15.2

mm_balance-0.4.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+mm_balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_balance/balance_fetcher.py,sha256=HUYoZkBdRSPb3AQ5MANOf1H9PQEyizaftXM4oCwp0Bs,3192
+mm_balance/cli.py,sha256=0ZD0fEhzEgrBrXyxUVfuMikrcqJ5w9LSJST4U8DlSIE,2699
+mm_balance/command_runner.py,sha256=4rWzQfGEznTNTm_tfVlp46FGlpUD0Wd7zFr0UyL1aws,2845
+mm_balance/config.py,sha256=yVB-46HR7saXSsGKbHoxsu6cRMUVTSiuoEPSpSSiOv0,4886
+mm_balance/constants.py,sha256=K1qOTHZNmv3_AsLAWzrRG5XCDBMOhVr1NLnL1_2bC08,2446
+mm_balance/diff.py,sha256=GPRbykty2TIBBM8jpYXOV9Itjyd_mz0BTUsQ8KX7cNo,7099
+mm_balance/price.py,sha256=QVnd0PTn-1ylVLJu230zVpGv5Bs8MgBkantU0pq2osE,1568
+mm_balance/result.py,sha256=yx691T0E6FAe-NSiFMnf1KHBgbCAZPBBQ9xLgKs4_1U,5175
+mm_balance/rpc.py,sha256=-alZDHjpcxna3fHDu_qDGCRMBupFU9x2NeOLGoUQM7U,6121
+mm_balance/token_decimals.py,sha256=di4-LVkXmqAFGc9vrXF_Kq1Oqx3YHWZhavjXrXmigC0,1953
+mm_balance/utils.py,sha256=_UMX3TV350Sr222tAnxGUf0R5McpwloNTQC-U-xiuHc,636
+mm_balance/config/example.toml,sha256=f3Jr40ziOCv_Txf-BysS89c9r7uS-IYHuvwbQ-iftUs,1802
+mm_balance/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_balance/output/utils.py,sha256=zyN9igdaXGY_vKfc-3dJ13mH1T7JDke3AeB4MY_3AsA,842
+mm_balance/output/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_balance/output/formats/json_format.py,sha256=ki0AK7Azft5SF9v14_8X_QT-NtyNWqw0MlQmxtV-VH8,921
+mm_balance/output/formats/table_format.py,sha256=aVf34CK0oVyzm5_mYWnV5BG7eFUah4BYE6DJD1-8bRk,4782
+mm_balance-0.4.0.dist-info/METADATA,sha256=IBj1ayGa0HlsY9yLV-qL5eSdmLGeCN5k74n_xh9sf7k,254
+mm_balance-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_balance-0.4.0.dist-info/entry_points.txt,sha256=rSnP0ZW1a3ACNwTWM7T53CmOycKbzhG43m2_wseENng,50
+mm_balance-0.4.0.dist-info/RECORD,,

mm_balance/rpc/aptos.py

@@ -1,23 +0,0 @@
-from decimal import Decimal
-
-from mm_aptos import balance
-from mm_std import Result
-
-from mm_balance.constants import RETRIES_BALANCE, TIMEOUT_BALANCE
-
-
-def get_balance(
-    nodes: list[str], wallet: str, token: str | None, decimals: int, proxies: list[str], round_ndigits: int
-) -> Result[Decimal]:
-    if token is None:
-        token = "0x1::aptos_coin::AptosCoin"  # noqa: S105 # nosec
-    return balance.get_decimal_balance_with_retries(
-        RETRIES_BALANCE,
-        nodes,
-        wallet,
-        token,
-        decimals=decimals,
-        timeout=TIMEOUT_BALANCE,
-        proxies=proxies,
-        round_ndigits=round_ndigits,
-    )

mm_balance/rpc/btc.py

@@ -1,15 +0,0 @@
-from decimal import Decimal
-
-from mm_btc.blockstream import BlockstreamClient
-from mm_std import Ok, Result
-
-from mm_balance.constants import RETRIES_BALANCE
-from mm_balance.utils import scale_and_round
-
-
-def get_balance(address: str, proxies: list[str], round_ndigits: int) -> Result[Decimal]:
-    return (
-        BlockstreamClient(proxies=proxies, attempts=RETRIES_BALANCE)
-        .get_confirmed_balance(address)
-        .and_then(lambda b: Ok(scale_and_round(b, 8, round_ndigits)))
-    )

mm_balance/rpc/evm.py

@@ -1,28 +0,0 @@
-from decimal import Decimal
-
-from mm_eth import erc20, rpc
-from mm_std import Ok, Result
-
-from mm_balance.constants import RETRIES_BALANCE, RETRIES_DECIMALS, TIMEOUT_BALANCE, TIMEOUT_DECIMALS
-from mm_balance.utils import scale_and_round
-
-
-def get_balance(
-    nodes: list[str], wallet: str, token: str | None, decimals: int, proxies: list[str], round_ndigits: int
-) -> Result[Decimal]:
-    if token is not None:
-        res = erc20.get_balance(
-            nodes,
-            token,
-            wallet,
-            proxies=proxies,
-            attempts=RETRIES_BALANCE,
-            timeout=TIMEOUT_BALANCE,
-        )
-    else:
-        res = rpc.eth_get_balance(nodes, wallet, proxies=proxies, attempts=RETRIES_BALANCE, timeout=TIMEOUT_BALANCE)
-    return res.and_then(lambda b: Ok(scale_and_round(b, decimals, round_ndigits)))
-
-
-def get_token_decimals(nodes: list[str], token_address: str, proxies: list[str]) -> Result[int]:
-    return erc20.get_decimals(nodes, token_address, timeout=TIMEOUT_DECIMALS, proxies=proxies, attempts=RETRIES_DECIMALS)

mm_balance/rpc/solana.py

@@ -1,27 +0,0 @@
-from decimal import Decimal
-
-from mm_sol import balance, token
-from mm_std import Ok, Result
-
-from mm_balance.constants import RETRIES_BALANCE, RETRIES_DECIMALS, TIMEOUT_BALANCE, TIMEOUT_DECIMALS
-from mm_balance.utils import scale_and_round
-
-
-def get_balance(
-    nodes: list[str], wallet: str, token: str | None, decimals: int, proxies: list[str], round_ndigits: int
-) -> Result[Decimal]:
-    if token is None:
-        res = balance.get_sol_balance_with_retries(
-            nodes, wallet, retries=RETRIES_BALANCE, timeout=TIMEOUT_BALANCE, proxies=proxies
-        )
-    else:
-        res = balance.get_token_balance_with_retries(
-            nodes, wallet, token, retries=RETRIES_BALANCE, timeout=TIMEOUT_BALANCE, proxies=proxies
-        )
-    return res.and_then(lambda b: Ok(scale_and_round(b, decimals, round_ndigits)))
-
-
-def get_token_decimals(nodes: list[str], token_address: str, proxies: list[str]) -> Result[int]:
-    return token.get_decimals_with_retries(
-        nodes, token_address, retries=RETRIES_DECIMALS, timeout=TIMEOUT_DECIMALS, proxies=proxies
-    )

mm_balance-0.3.0.dist-info/METADATA

@@ -1,10 +0,0 @@
-Metadata-Version: 2.4
-Name: mm-balance
-Version: 0.3.0
-Requires-Python: >=3.12
-Requires-Dist: deepdiff==8.2.0
-Requires-Dist: mm-aptos==0.2.0
-Requires-Dist: mm-btc==0.3.0
-Requires-Dist: mm-eth==0.5.3
-Requires-Dist: mm-sol==0.5.1
-Requires-Dist: typer==0.15.1

mm_balance-0.3.0.dist-info/RECORD

@@ -1,25 +0,0 @@
-mm_balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_balance/cli.py,sha256=nRDVejN-dnr1iRezBxNk4z0oLa59tiwzIVhgeOGzvbo,4498
-mm_balance/config.py,sha256=gywHNWEQL1xeG778cuca5aBoXElLIfoGle3xxW6m_0U,4564
-mm_balance/constants.py,sha256=kqG2zuwv0l-PzDHIrMJVQpfQWiXjr2DsqGPcKmqNJLo,2334
-mm_balance/diff.py,sha256=GPRbykty2TIBBM8jpYXOV9Itjyd_mz0BTUsQ8KX7cNo,7099
-mm_balance/price.py,sha256=DzvcQngS6wgi_4YWoXxGvOuOkwJvUbN0KI8DeIxbB5A,1494
-mm_balance/result.py,sha256=-Ebq07JMLcQAmRs82cA6aYMbsT1qbZSyAOixr9K_wbg,5157
-mm_balance/token_decimals.py,sha256=N3YppB2F3J_OuNkawpAHLVD-4MRCoVjBI01_OoRg5sY,2201
-mm_balance/utils.py,sha256=_UMX3TV350Sr222tAnxGUf0R5McpwloNTQC-U-xiuHc,636
-mm_balance/workers.py,sha256=eg0Ve1xVu3Kd_thfVmPsp6tEdJsYYvs1ipXiu5rKItY,3758
-mm_balance/config/example.toml,sha256=f3Jr40ziOCv_Txf-BysS89c9r7uS-IYHuvwbQ-iftUs,1802
-mm_balance/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_balance/output/utils.py,sha256=zyN9igdaXGY_vKfc-3dJ13mH1T7JDke3AeB4MY_3AsA,842
-mm_balance/output/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_balance/output/formats/json_format.py,sha256=japDhWBVaZ9Znwrhi6BLsUEyn2zyNVxPFYhH7SiILb8,893
-mm_balance/output/formats/table_format.py,sha256=QtWq6ETIccfBTw-9SPypeZrX2zfZwpoCFi_Qe_qOLAA,4751
-mm_balance/rpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_balance/rpc/aptos.py,sha256=1JCYCqDim4tk1axXscaAJRXPd4J6vV1ABFbwMbPgrL0,641
-mm_balance/rpc/btc.py,sha256=wBMxUjbqdQipVsTFVkj4tk7loErA2czLVfvG8vjFLeE,493
-mm_balance/rpc/evm.py,sha256=LaU2csGL-VlQauCiTX_WFnstvTyZLMP5gDw2LyV53m8,1048
-mm_balance/rpc/solana.py,sha256=10rJ4eEr9sfEfhXx-X2R7bdJ5dL7bVMwHHfJ4R3QR7U,1071
-mm_balance-0.3.0.dist-info/METADATA,sha256=Owy1HtXoCk7RhiqeEwijv80KKLuDBHbgQdHOrjAxvEs,256
-mm_balance-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_balance-0.3.0.dist-info/entry_points.txt,sha256=rSnP0ZW1a3ACNwTWM7T53CmOycKbzhG43m2_wseENng,50
-mm_balance-0.3.0.dist-info/RECORD,,