mm-balance 0.1.13__tar.gz → 0.1.15__tar.gz

{mm_balance-0.1.13 → mm_balance-0.1.15}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.3
 Name: mm-balance
-Version: 0.1.13
+Version: 0.1.15
 Requires-Python: >=3.12
+Requires-Dist: mm-aptos==0.1.2
 Requires-Dist: mm-btc==0.1.0
 Requires-Dist: mm-eth==0.1.3
 Requires-Dist: mm-solana==0.1.5

{mm_balance-0.1.13 → mm_balance-0.1.15}/justfile

@@ -20,7 +20,7 @@ lint: format
     uv run mypy src
 
 audit:
-    uv run pip-audit
+    uv run pip-audit --ignore-vuln GHSA-f9vj-2wh5-fj8j --ignore-vuln GHSA-q34m-jh98-gwm2
     uv run bandit -r -c "pyproject.toml" src
 
 publish: build

{mm_balance-0.1.13 → mm_balance-0.1.15}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "mm-balance"
-version = "0.1.13"
+version = "0.1.15"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
     "mm-btc==0.1.0",
     "mm-eth==0.1.3",
     "mm-solana==0.1.5",
+    "mm-aptos==0.1.2",
     "typer>=0.12.5",
 ]
 [project.scripts]
@@ -21,11 +22,11 @@ dev-dependencies = [
     "pytest~=8.3.3",
     "pytest-xdist~=3.6.1",
     "pytest-httpserver~=1.1.0",
-    "coverage~=7.6.3",
-    "ruff~=0.6.9",
+    "coverage~=7.6.4",
+    "ruff~=0.7.1",
     "pip-audit~=2.7.0",
     "bandit~=1.7.10",
-    "mypy~=1.12.0",
+    "mypy~=1.13.0",
     "types-python-dateutil~=2.9.0.20241003",
     "types-PyYAML~=6.0.12.20240917",
 ]

mm_balance-0.1.15/src/mm_balance/cli.py

@@ -0,0 +1,84 @@
+import getpass
+import pathlib
+import pkgutil
+from typing import Annotated
+
+import typer
+from mm_std import PrintFormat, fatal
+
+from mm_balance.config import Config
+from mm_balance.constants import NETWORKS
+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)
+
+
+def example_callback(value: bool) -> None:
+    if value:
+        data = pkgutil.get_data(__name__, "config/example.yml")
+        typer.echo(data)
+        raise typer.Exit
+
+
+def networks_callback(value: bool) -> None:
+    if value:
+        for network in NETWORKS:
+            typer.echo(network)
+        raise typer.Exit
+
+
+@app.command()
+def cli(
+    config_path: Annotated[pathlib.Path, typer.Argument()],
+    print_format: Annotated[PrintFormat | None, typer.Option("--format", "-f", help="Print format.")] = None,
+    skip_empty: Annotated[bool | None, typer.Option("--skip-empty", "-s", help="Skip empty balances.")] = None,
+    debug: Annotated[bool | None, typer.Option("--debug", "-d", help="Print debug info.")] = None,
+    price: Annotated[bool | None, typer.Option("--price/--no-price", help="Print prices.")] = 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,
+) -> None:
+    zip_password = ""  # nosec
+    if config_path.name.endswith(".zip"):
+        zip_password = getpass.getpass("zip password")
+    config = Config.read_config(config_path, zip_password=zip_password)
+
+    if print_format is not None:
+        config.print_format = print_format
+    if debug is not None:
+        config.print_debug = debug
+    if skip_empty is not None:
+        config.skip_empty = skip_empty
+    if price is not None:
+        config.price = price
+
+    if config.print_debug and config.print_format is PrintFormat.TABLE:
+        table_format.print_nodes(config)
+
+    token_decimals = get_token_decimals(config)
+    if config.print_debug and config.print_format is PrintFormat.TABLE:
+        table_format.print_token_decimals(token_decimals)
+
+    prices = get_prices(config) if config.price else Prices()
+    if config.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.print_format is PrintFormat.TABLE:
+        table_format.print_result(config, result, workers)
+    elif config.print_format is PrintFormat.JSON:
+        json_format.print_result(config, token_decimals, prices, workers, result)
+    else:
+        fatal("Unsupported print format")
+
+
+if __name__ == "__main__":
+    app()

{mm_balance-0.1.13 → mm_balance-0.1.15}/src/mm_balance/config/example.yml

@@ -38,6 +38,14 @@ coins:
     comment: binance
     addresses: binance_eth
 
+  - ticker: USDC
+    comment: okx aptos
+    network: aptos
+    token_address: 0xf22bede237a07e121b56d91a491eb7bcdfd1f5907926a9e58338f964a01b17fa::asset::USDC
+    token_decimals: 6
+    addresses: "0x834d639b10d20dcb894728aa4b9b572b2ea2d97073b10eacb111f338b20ea5d7" # for a single line it's necessary to use quotes
+
+
 addresses:
   - name: okx_eth
     addresses: |
@@ -61,3 +69,6 @@ addresses:
 #round_ndigits: 4
 #price: yes
 #skip_empty: no
+#print_debug: no
+#print_format: table # table, json
+#format_number_separator: ","

{mm_balance-0.1.13 → mm_balance-0.1.15}/src/mm_balance/config.py

@@ -15,7 +15,8 @@ class Group(BaseConfig):
     comment: str = ""
     ticker: str
     network: Network
-    token_address: str | None = None
+    token_address: str | None = None  # If None, it's a native token, for example ETH
+    token_decimals: int | None = None
     coingecko_id: str | None = None
     addresses: list[str] = Field(default_factory=list)
     share: Decimal = Decimal(1)
@@ -25,7 +26,7 @@ class Group(BaseConfig):
         result = self.ticker
         if self.comment:
             result += " / " + self.comment
-        result += " / " + self.network.value
+        result += " / " + self.network
         return result
 
     @field_validator("ticker", mode="after")
@@ -46,7 +47,7 @@ class Group(BaseConfig):
     def final_validator(self) -> Self:
         if self.token_address is None:
             self.token_address = detect_token_address(self.ticker, self.network)
-        if self.token_address is not None and self.network is Network.ETHEREUM:
+        if self.token_address is not None and self.network.is_evm_network():
             self.token_address = self.token_address.lower()
         return self
 
@@ -81,12 +82,16 @@ class Config(BaseConfig):
     print_format: PrintFormat = PrintFormat.TABLE
     price: bool = True
     skip_empty: bool = False  # don't print the address with an empty balance
-
-    workers: dict[Network, int] = {network: 5 for network in Network}
+    print_debug: bool = False  # print debug info: nodes, token_decimals
+    format_number_separator: str = ","  #  as thousands separators
+    workers: dict[Network, int] = Field(default_factory=dict)
 
     def has_share(self) -> bool:
         return any(g.share != Decimal(1) for g in self.groups)
 
+    def networks(self) -> list[Network]:
+        return pydash.uniq([group.network for group in self.groups])
+
     @model_validator(mode="after")
     def final_validator(self) -> Self:
         # load from proxies_url
@@ -98,10 +103,15 @@ class Config(BaseConfig):
             group.process_addresses(self.addresses)
 
         # load default rpc nodes
-        for network in Network:
+        for network in self.networks():
             if network not in self.nodes:
                 self.nodes[network] = DEFAULT_NODES[network]
 
+        # load default workers
+        for network in self.networks():
+            if network not in self.workers:
+                self.workers[network] = 5
+
         return self
 
 

mm_balance-0.1.15/src/mm_balance/constants.py

@@ -0,0 +1,69 @@
+from typing import Any
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+RETRIES_BALANCE = 5
+RETRIES_DECIMALS = 5
+RETRIES_COINGECKO_PRICES = 5
+TIMEOUT_BALANCE = 5
+TIMEOUT_DECIMALS = 5
+
+
+class Network(str):
+    def is_evm_network(self) -> bool:
+        return self in [NETWORK_ETHEREUM, NETWORK_ARBITRUM_ONE, NETWORK_OP_MAINNET] or self.startswith("evm-")
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(cls, handler(str))
+
+
+NETWORK_APTOS = Network("aptos")
+NETWORK_ARBITRUM_ONE = Network("arbitrum-one")
+NETWORK_BITCOIN = Network("bitcoin")
+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]
+
+
+TOKEN_ADDRESS: dict[Network, dict[str, str]] = {
+    NETWORK_ETHEREUM: {
+        "USDT": "0xdac17f958d2ee523a2206206994597c13d831ec7",
+        "USDC": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    },
+    NETWORK_SOLANA: {
+        "USDT": "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+        "USDC": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    },
+    NETWORK_ARBITRUM_ONE: {
+        "USDT": "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+        "USDC": "0xff970a61a04b1ca14834a43f5de4533ebddb5cc8",
+    },
+    NETWORK_OP_MAINNET: {
+        "USDT": "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58",
+        "USDC": "0x7f5c764cbc14f9669b88837ca1490cca17c31607",
+    },
+}
+
+TICKER_TO_COINGECKO_ID = {
+    "BTC": "bitcoin",
+    "ETH": "ethereum",
+    "USDT": "tether",
+    "USDC": "usd-coin",
+    "SOL": "solana",
+    "APT": "aptos",
+    "POL": "matic-network",
+}
+
+USD_STABLECOINS = ["USDT", "USDC"]
+
+DEFAULT_NODES: dict[Network, list[str]] = {
+    NETWORK_ARBITRUM_ONE: ["https://arb1.arbitrum.io/rpc", "https://arbitrum.llamarpc.com"],
+    NETWORK_BITCOIN: [],
+    NETWORK_ETHEREUM: ["https://ethereum.publicnode.com", "https://rpc.ankr.com/eth"],
+    NETWORK_SOLANA: ["https://api.mainnet-beta.solana.com"],
+    NETWORK_OP_MAINNET: ["https://mainnet.optimism.io", "https://optimism.llamarpc.com"],
+    NETWORK_APTOS: ["https://fullnode.mainnet.aptoslabs.com/v1"],
+}

mm_balance-0.1.15/src/mm_balance/output/formats/json_format.py

@@ -0,0 +1,27 @@
+from mm_std import print_json
+
+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:
+    data: dict[str, object] = {}
+    if config.print_debug:
+        data["nodes"] = config.nodes
+        data["token_decimals"] = token_decimals
+    if config.price:
+        data["prices"] = prices
+
+    data["groups"] = result.groups
+    data["total"] = result.total
+    if config.has_share():
+        data["total_share"] = result.total_share
+
+    errors = workers.get_errors()
+    if errors:
+        data["errors"] = errors
+
+    print_json(data)

mm_balance-0.1.15/src/mm_balance/output/formats/table_format.py

@@ -0,0 +1,115 @@
+from decimal import Decimal
+
+from mm_std import print_table
+
+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:
+    rows = []
+    for network, nodes in config.nodes.items():
+        rows.append([network, "\n".join(nodes)])
+    print_table("Nodes", ["network", "nodes"], rows)
+
+
+def print_token_decimals(token_decimals: TokenDecimals) -> None:
+    rows = []
+    for network, decimals in token_decimals.items():
+        rows.append([network, decimals])
+    print_table("Token Decimals", ["network", "decimals"], rows)
+
+
+def print_prices(config: Config, prices: Prices) -> None:
+    if config.price:
+        rows = []
+        for ticker, price in prices.items():
+            rows.append([ticker, format_number(round(price, config.round_ndigits), config.format_number_separator, "$")])
+        print_table("Prices", ["coin", "usd"], rows)
+
+
+def print_result(config: Config, result: BalancesResult, workers: Workers) -> None:
+    for group in result.groups:
+        _print_group(config, group)
+
+    _print_total(config, result.total, False)
+    if config.has_share():
+        _print_total(config, result.total_share, True)
+
+    _print_errors(config, workers)
+
+
+def _print_errors(config: Config, workers: Workers) -> 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]
+    print_table("Errors", ["coin", "address", "error"], rows)
+
+
+def _print_total(config: Config, total: Total, is_share_total: bool) -> None:
+    table_name = "Total, share" if is_share_total else "Total"
+    headers = ["coin", "balance"]
+
+    rows = []
+    for ticker, balance in total.coin_balances.items():
+        balance_str = format_number(balance, config.format_number_separator)
+        row = [ticker, balance_str]
+        if config.price:
+            usd_value_str = format_number(total.coin_usd_values[ticker], config.format_number_separator, "$")
+            portfolio_share = total.portfolio_share[ticker]
+            row += [usd_value_str, f"{portfolio_share}%"]
+        rows.append(row)
+
+    if config.price:
+        headers += ["usd", "portfolio_share"]
+        if total.stablecoin_sum > 0:
+            rows.append(["stablecoin_sum", format_number(total.stablecoin_sum, config.format_number_separator, "$")])
+        rows.append(["total_usd_sum", format_number(total.total_usd_sum, config.format_number_separator, "$")])
+
+    print_table(table_name, headers, rows)
+
+
+def _print_group(config: Config, group: GroupResult) -> None:
+    group_name = group.ticker
+    if group.comment:
+        group_name += " / " + group.comment
+    group_name += " / " + group.network
+
+    rows = []
+    for address in group.addresses:
+        if isinstance(address.balance, str):
+            rows.append([address.address, address.balance])
+        else:
+            if config.skip_empty and address.balance.balance == Decimal(0):
+                continue
+            balance_str = format_number(address.balance.balance, config.format_number_separator)
+            row = [address.address, balance_str]
+            if config.price:
+                usd_value_str = format_number(address.balance.usd_value, config.format_number_separator, "$")
+                row.append(usd_value_str)
+            rows.append(row)
+
+    sum_row = ["sum", format_number(group.balance_sum, config.format_number_separator)]
+    if config.price:
+        sum_row.append(format_number(group.usd_sum, config.format_number_separator, "$"))
+    rows.append(sum_row)
+
+    if group.share < Decimal(1):
+        sum_share_str = format_number(group.balance_sum_share, config.format_number_separator)
+        sum_share_row = [f"sum_share, {group.share}", sum_share_str]
+        if config.price:
+            sum_share_row.append(format_number(group.usd_sum_share, config.format_number_separator, "$"))
+        rows.append(sum_share_row)
+
+    table_headers = ["address", "balance"]
+    if config.price:
+        table_headers += ["usd"]
+    print_table(group_name, table_headers, rows)

mm_balance-0.1.15/src/mm_balance/output/utils.py

@@ -0,0 +1,20 @@
+from decimal import Decimal
+
+from rich.progress import BarColumn, MofNCompleteColumn, Progress, TaskID, TextColumn
+
+
+def format_number(value: Decimal, separator: str, extra: str | None = None) -> str:
+    str_value = f"{value:,}".replace(",", separator)
+    if extra == "$":
+        return "$" + str_value
+    elif extra == "%":
+        return str_value + "%"
+    return str_value
+
+
+def create_progress_bar(disable: bool) -> Progress:
+    return Progress(TextColumn("[progress.description]{task.description}"), BarColumn(), MofNCompleteColumn(), disable=disable)
+
+
+def create_progress_task(progress: Progress, description: str, total: int) -> TaskID:
+    return progress.add_task("[green]" + description, total=total)

{mm_balance-0.1.13 → mm_balance-0.1.15}/src/mm_balance/price.py

@@ -5,7 +5,7 @@ from mm_std import fatal, hr
 from mm_std.random_ import random_str_choice
 
 from mm_balance.config import Config, Group
-from mm_balance.constants import RETRIES_COINGECKO_PRICES, Network
+from mm_balance.constants import RETRIES_COINGECKO_PRICES, TICKER_TO_COINGECKO_ID
 
 
 class Prices(dict[str, Decimal]):
@@ -38,29 +38,11 @@ def get_prices(config: Config) -> Prices:
     return result
 
 
-TICKER_TO_COINGECKO_ID = {
-    "BTC": "bitcoin",
-    "ETH": "ethereum",
-    "USDT": "tether",
-    "USDC": "usd-coin",
-    "SOL": "solana",
-}
-
-
 def get_coingecko_id(group: Group) -> str:
     if group.coingecko_id:
         return group.coingecko_id
-    elif group.network is Network.BITCOIN:
-        return "bitcoin"
-    elif group.network is Network.ETHEREUM and group.token_address is None:
-        return "ethereum"
-    elif group.ticker == "ETH":
-        return "ethereum"
-    elif group.ticker == "USDT":
-        return "tether"
-    elif group.ticker == "USDC":
-        return "usd-coin"
-    elif group.ticker == "SOL":
-        return "solana"
+    coingecko_id = TICKER_TO_COINGECKO_ID.get(group.ticker)
+    if coingecko_id:
+        return coingecko_id
 
-    raise ValueError(f"can't get coingecko_id for {group.ticker}")
+    fatal(f"Can't get coingecko_id for {group.ticker}. Please add coingecko_id to the config.")

mm_balance-0.1.15/src/mm_balance/result.py

@@ -0,0 +1,131 @@
+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.constants import USD_STABLECOINS, Network
+from mm_balance.price import Prices
+from mm_balance.workers import Task, Workers
+
+
+@dataclass
+class Balance:
+    balance: Decimal
+    usd_value: Decimal  # 0 if config.price is False
+
+
+@dataclass
+class AddressBalance:
+    address: str
+    balance: Balance | str  # balance value or error message
+
+
+@dataclass
+class GroupResult:
+    ticker: str
+    network: Network
+    comment: str
+    share: Decimal
+    addresses: list[AddressBalance]
+    balance_sum: Decimal  # sum of all balances in the group
+    usd_sum: Decimal  # sum of all usd values in the group
+    balance_sum_share: Decimal  # sum of all balances in the group multiplied by share
+    usd_sum_share: Decimal  # sum of all usd values in the group multiplied by share
+
+
+@dataclass
+class Total:
+    coin_balances: dict[str, Decimal]
+    coin_usd_values: dict[str, Decimal]
+    portfolio_share: dict[str, Decimal]  # ticker -> usd value % from total usd value
+    stablecoin_sum: Decimal  # sum of usd stablecoins: usdt, usdc, etc..
+    total_usd_sum: Decimal  # sum of all coins in USD
+
+
+@dataclass
+class BalancesResult:
+    groups: list[GroupResult]
+    total: Total
+    total_share: Total
+
+
+def create_balances_result(config: Config, prices: Prices, workers: Workers) -> BalancesResult:
+    groups = []
+    for group_index, group in enumerate(config.groups):
+        tasks = workers.get_group_tasks(group_index, group.network)
+        groups.append(_create_group_result(config, group, tasks, prices))
+
+    total = _create_total(False, groups)
+    total_share = _create_total(True, groups)
+    return BalancesResult(groups=groups, total=total, total_share=total_share)
+
+
+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
+    portfolio_share: dict[str, Decimal] = defaultdict(Decimal)  # ticker -> usd value % from total usd value
+    total_usd_sum = Decimal(0)
+    stablecoin_sum = Decimal(0)
+
+    for group in groups:
+        balance_value = group.balance_sum_share if use_share else group.balance_sum
+        usd_value = group.usd_sum_share if use_share else group.usd_sum
+        coin_balances[group.ticker] += balance_value
+        coin_usd_values[group.ticker] += usd_value
+        if group.ticker in USD_STABLECOINS:
+            stablecoin_sum += usd_value  # TODO: or balance_value?
+        total_usd_sum += usd_value
+
+    if total_usd_sum > 0:
+        for ticker, usd_value in coin_usd_values.items():
+            if ticker in USD_STABLECOINS:
+                portfolio_share[ticker] = round(stablecoin_sum * 100 / total_usd_sum, 2)
+            else:
+                portfolio_share[ticker] = round(usd_value * 100 / total_usd_sum, 2)
+
+    return Total(
+        coin_balances=coin_balances,
+        coin_usd_values=coin_usd_values,
+        portfolio_share=portfolio_share,
+        stablecoin_sum=stablecoin_sum,
+        total_usd_sum=total_usd_sum,
+    )
+
+
+def _create_group_result(config: Config, group: Group, tasks: list[Task], prices: Prices) -> GroupResult:
+    addresses = []
+    balance_sum = Decimal(0)
+    usd_sum = Decimal(0)
+    for task in tasks:
+        balance: Balance | str
+        if task.balance is None:
+            balance = "balance is None! Something went wrong."
+        else:
+            if isinstance(task.balance, Ok):
+                coin_value = task.balance.ok
+                usd_value = Decimal(0)
+                if group.ticker in prices:
+                    usd_value = round(coin_value * prices[group.ticker], config.round_ndigits)
+                balance = Balance(balance=coin_value, usd_value=usd_value)
+                balance_sum += balance.balance
+                usd_sum += balance.usd_value
+            else:
+                balance = task.balance.err
+        addresses.append(AddressBalance(address=task.wallet_address, balance=balance))
+
+    balance_sum_share = balance_sum * group.share
+    usd_sum_share = usd_sum * group.share
+
+    return GroupResult(
+        ticker=group.ticker,
+        network=group.network,
+        comment=group.comment,
+        share=group.share,
+        addresses=addresses,
+        balance_sum=balance_sum,
+        usd_sum=usd_sum,
+        balance_sum_share=balance_sum_share,
+        usd_sum_share=usd_sum_share,
+    )

mm_balance-0.1.15/src/mm_balance/rpc/aptos.py

@@ -0,0 +1,23 @@
+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"  # 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-0.1.15/src/mm_balance/rpc/evm.py

@@ -0,0 +1,27 @@
+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
+
+
+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(round(Decimal(b / 10**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)