mm-balance 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

mm_balance/balances.py

@@ -8,8 +8,8 @@ from rich.progress import TaskID
 
 from mm_balance import output
 from mm_balance.config import Config
-from mm_balance.constants import Network
-from mm_balance.rpc import btc, eth, solana
+from mm_balance.constants import NETWORK_APTOS, NETWORK_BITCOIN, NETWORK_SOLANA, Network
+from mm_balance.rpc import aptos, btc, evm, solana
 from mm_balance.token_decimals import TokenDecimals
 
 
@@ -23,7 +23,7 @@ class Balances:
     def __init__(self, config: Config, token_decimals: TokenDecimals):
         self.config = config
         self.token_decimals = token_decimals
-        self.tasks: dict[Network, list[Balances.Balance]] = {network: [] for network in Network}
+        self.tasks: dict[Network, list[Balances.Balance]] = {network: [] for network in config.networks()}
         self.progress_bar = output.create_progress_bar()
         self.progress_bar_task: dict[Network, TaskID] = {}
 
@@ -31,17 +31,17 @@ class Balances:
             task_list = [Balances.Balance(group_index=idx, address=a, token_address=group.token_address) for a in group.addresses]
             self.tasks[group.network].extend(task_list)
 
-        for network in Network:
+        for network in config.networks():
             if self.tasks[network]:
                 self.progress_bar_task[network] = output.create_progress_task(
-                    self.progress_bar, network.value, len(self.tasks[network])
+                    self.progress_bar, network, len(self.tasks[network])
                 )
 
     def process(self) -> None:
         with self.progress_bar:
             job = ConcurrentTasks(max_workers=10)
-            for network in Network:
-                job.add_task(network.value, self._process_network, args=(network,))
+            for network in self.config.networks():
+                job.add_task(network, self._process_network, args=(network,))
             job.execute()
 
     def _process_network(self, network: Network) -> None:
@@ -49,6 +49,7 @@ class Balances:
         for idx, task in enumerate(self.tasks[network]):
             job.add_task(str(idx), self._get_balance, args=(network, task.address, task.token_address))
         job.execute()
+        # 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]
 
@@ -56,23 +57,18 @@ class Balances:
         nodes = self.config.nodes[network]
         round_ndigits = self.config.round_ndigits
         proxies = self.config.proxies
-        token_decimals = self.token_decimals[network][token_address] if token_address else -1
-        match network:
-            case Network.BITCOIN:
-                res = btc.get_balance(wallet_address, proxies, round_ndigits)
-            case Network.ETHEREUM | Network.ARBITRUM_ONE | Network.OP_MAINNET:
-                if token_address is None:
-                    res = eth.get_native_balance(nodes, wallet_address, proxies, round_ndigits)
-                else:
-                    res = eth.get_token_balance(nodes, wallet_address, token_address, token_decimals, proxies, round_ndigits)
-            case Network.SOLANA:
-                if token_address is None:
-                    res = solana.get_native_balance(nodes, wallet_address, proxies, round_ndigits)
-                else:
-                    res = solana.get_token_balance(nodes, wallet_address, token_address, token_decimals, proxies, round_ndigits)
+        token_decimals = self.token_decimals[network][token_address]
 
-            case _:
-                raise ValueError
+        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.progress_bar.update(self.progress_bar_task[network], advance=1)
         return res
@@ -80,3 +76,11 @@ class Balances:
     def get_group_balances(self, group_index: int, network: Network) -> list[Balance]:
         # 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[Balance]:
+        result = []
+        for network in self.tasks:
+            for task in self.tasks[network]:
+                if task.balance is not None and task.balance.is_err():
+                    result.append(task)
+        return result

mm_balance/cli.py

@@ -8,7 +8,7 @@ import typer
 from mm_balance import output
 from mm_balance.balances import Balances
 from mm_balance.config import Config
-from mm_balance.constants import Network
+from mm_balance.constants import NETWORKS
 from mm_balance.price import Prices, get_prices
 from mm_balance.token_decimals import get_token_decimals
 
@@ -24,7 +24,7 @@ def example_callback(value: bool) -> None:
 
 def networks_callback(value: bool) -> None:
     if value:
-        for network in Network:
+        for network in NETWORKS:
             typer.echo(network)
         raise typer.Exit
 
@@ -42,15 +42,22 @@ def cli(
         zip_password = getpass.getpass("zip password")
     config = Config.read_config(config_path, zip_password=zip_password)
 
+    if config.print_debug:
+        output.print_nodes(config)
+
+    token_decimals = get_token_decimals(config)
+    if config.print_debug:
+        output.print_token_decimals(token_decimals)
+
     prices = get_prices(config) if config.price else Prices()
     output.print_prices(config, prices)
 
-    token_decimals = get_token_decimals(config)
     balances = Balances(config, token_decimals)
     balances.process()
 
     output.print_groups(balances, config, prices)
     output.print_total(config, balances, prices)
+    output.print_errors(config, balances)
 
 
 if __name__ == "__main__":

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: |
@@ -60,3 +68,6 @@ addresses:
 #- http://123.123.123.124
 #round_ndigits: 4
 #price: yes
+#skip_empty: no
+#print_debug: no
+#format_number_separator: ","

mm_balance/config.py

@@ -1,26 +1,22 @@
 from __future__ import annotations
 
 from decimal import Decimal
+from pathlib import Path
 from typing import Self
 
 import pydash
 from mm_std import BaseConfig, PrintFormat, fatal, hr
 from pydantic import Field, field_validator, model_validator
 
-from mm_balance.constants import (
-    DEFAULT_ARBITRUM_ONE_NODES,
-    DEFAULT_ETHEREUM_NODES,
-    DEFAULT_SOLANA_NODES,
-    TOKEN_ADDRESS,
-    Network,
-)
+from mm_balance.constants import DEFAULT_NODES, TOKEN_ADDRESS, Network
 
 
 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)
@@ -30,11 +26,11 @@ 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")
-    def coin_validator(cls, v: str) -> str:
+    def ticker_validator(cls, v: str) -> str:
         return v.upper()
 
     @field_validator("addresses", mode="before")
@@ -51,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
 
@@ -63,7 +59,7 @@ class Group(BaseConfig):
             else:
                 # TODO: check address is valid
                 addresses.append(address)
-        self.addresses = addresses
+        self.addresses = pydash.uniq(process_file_addresses(addresses))
 
 
 class AddressGroup(BaseConfig):
@@ -85,12 +81,17 @@ class Config(BaseConfig):
     nodes: dict[Network, list[str]] = Field(default_factory=dict)
     print_format: PrintFormat = PrintFormat.TABLE
     price: bool = True
-
-    workers: dict[Network, int] = {network: 5 for network in Network}
+    skip_empty: bool = False  # don't print the address with an empty balance
+    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
@@ -102,36 +103,21 @@ class Config(BaseConfig):
             group.process_addresses(self.addresses)
 
         # load default rpc nodes
-        if Network.BITCOIN not in self.nodes:
-            self.nodes[Network.BITCOIN] = []
-        if Network.ETHEREUM not in self.nodes:
-            self.nodes[Network.ETHEREUM] = DEFAULT_ETHEREUM_NODES
-        if Network.ARBITRUM_ONE not in self.nodes:
-            self.nodes[Network.ARBITRUM_ONE] = DEFAULT_ARBITRUM_ONE_NODES
-        if Network.OP_MAINNET not in self.nodes:
-            self.nodes[Network.OP_MAINNET] = DEFAULT_ARBITRUM_ONE_NODES
-        if Network.SOLANA not in self.nodes:
-            self.nodes[Network.SOLANA] = DEFAULT_SOLANA_NODES
-
-        return self
+        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
 
-# def detect_network(coin: str) -> Network:
-#
-#     # coin = coin.lower()
-#     # if coin == "btc":
-#     #     return Network.BTC
-#     # if coin == "eth":
-#     #     return Network.ETH
-#     # if coin == "sol":
-#     #     return Network.SOL
-#     # return Network.ETH
-#     # # TODO: raise ValueError(f"can't get network for the coin: {coin}")
+        return self
 
 
-def detect_token_address(coin: str, network: Network) -> str | None:
+def detect_token_address(ticker: str, network: Network) -> str | None:
     if network in TOKEN_ADDRESS:
-        return TOKEN_ADDRESS[network].get(coin)
+        return TOKEN_ADDRESS[network].get(ticker)
 
 
 def get_proxies(proxies_url: str) -> list[str]:
@@ -147,3 +133,17 @@ def get_proxies(proxies_url: str) -> list[str]:
 
 def get_address_group_by_name(address_groups: list[AddressGroup], name: str) -> AddressGroup | None:
     return pydash.find(address_groups, lambda g: g.name == name)
+
+
+def process_file_addresses(addresses: list[str]) -> list[str]:
+    result = []
+    for address in addresses:
+        if address.startswith("file://"):
+            path = Path(address.removeprefix("file://"))
+            if path.is_file():
+                result.extend(path.read_text().strip().splitlines())
+            else:
+                fatal(f"File with addresses not found: {path}")
+        else:
+            result.append(address)
+    return result

mm_balance/constants.py

@@ -1,6 +1,7 @@
-from __future__ import annotations
+from typing import Any
 
-from enum import Enum, unique
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
 
 RETRIES_BALANCE = 5
 RETRIES_DECIMALS = 5
@@ -9,25 +10,41 @@ TIMEOUT_BALANCE = 5
 TIMEOUT_DECIMALS = 5
 
 
-@unique
-class Network(str, Enum):
-    ARBITRUM_ONE = "arbitrum-one"
-    BITCOIN = "bitcoin"
-    ETHEREUM = "ethereum"
-    SOLANA = "solana"
-    OP_MAINNET = "op-mainnet"  # Optimism mainnet
+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: {
+    NETWORK_ETHEREUM: {
         "USDT": "0xdac17f958d2ee523a2206206994597c13d831ec7",
         "USDC": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
     },
-    Network.SOLANA: {
+    NETWORK_SOLANA: {
         "USDT": "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
         "USDC": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
     },
-    # TODO: Add for Arbitrum and Optimism, usdt + usdc
+    NETWORK_ARBITRUM_ONE: {
+        "USDT": "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+        "USDC": "0xff970a61a04b1ca14834a43f5de4533ebddb5cc8",
+    },
+    NETWORK_OP_MAINNET: {
+        "USDT": "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58",
+        "USDC": "0x7f5c764cbc14f9669b88837ca1490cca17c31607",
+    },
 }
 
 TICKER_TO_COINGECKO_ID = {
@@ -36,11 +53,17 @@ TICKER_TO_COINGECKO_ID = {
     "USDT": "tether",
     "USDC": "usd-coin",
     "SOL": "solana",
+    "APT": "aptos",
+    "POL": "matic-network",
 }
 
 USD_STABLECOINS = ["USDT", "USDC"]
 
-DEFAULT_ETHEREUM_NODES = ["https://ethereum.publicnode.com", "https://rpc.ankr.com/eth"]
-DEFAULT_SOLANA_NODES = ["https://api.mainnet-beta.solana.com"]
-DEFAULT_ARBITRUM_ONE_NODES = ["https://arb1.arbitrum.io/rpc", "https://arbitrum.llamarpc.com"]
-DEFAULT_OP_MAINNET_NODES = ["https://mainnet.optimism.io", "https://optimism.llamarpc.com"]
+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/output.py

@@ -1,12 +1,14 @@
 from decimal import Decimal
 
-from mm_std import Ok, print_table
+from mm_std import Err, Ok, fatal, print_table
 from rich.progress import BarColumn, MofNCompleteColumn, Progress, TaskID, TextColumn
 
 from mm_balance.balances import Balances
 from mm_balance.config import Config, Group
 from mm_balance.price import Prices
+from mm_balance.token_decimals import TokenDecimals
 from mm_balance.total import Total
+from mm_balance.utils import fnumber
 
 
 def print_groups(balances: Balances, config: Config, prices: Prices) -> None:
@@ -20,24 +22,35 @@ def _print_group(group: Group, group_balances: list[Balances.Balance], config: C
     balance_sum = Decimal(0)
     usd_sum = Decimal(0)
     for address_task in group_balances:
-        row = [address_task.address, address_task.balance.ok_or_err()]  # type: ignore[union-attr]
-        if isinstance(address_task.balance, Ok):
-            balance_sum += address_task.balance.ok
+        if isinstance(address_task.balance, Err):
+            row = [address_task.address, address_task.balance.err]
+        elif isinstance(address_task.balance, Ok):
+            balance = address_task.balance.ok
+            balance_sum += balance
+            if config.skip_empty and balance == Decimal(0):
+                continue
+            row = [address_task.address, fnumber(balance, config.format_number_separator)]
             if config.price:
-                balance_usd = round(address_task.balance.ok * prices[group.ticker], config.round_ndigits)
+                balance_usd = round(balance * prices[group.ticker], config.round_ndigits)
                 usd_sum += balance_usd
-                row.append(f"${balance_usd}")
+                row.append(fnumber(balance_usd, config.format_number_separator, "$"))
+        else:
+            fatal("address_task is None!")
         rows.append(row)
 
-    sum_row = ["sum", round(balance_sum, config.round_ndigits)]
+    balance_sum_str = fnumber(round(balance_sum, config.round_ndigits), config.format_number_separator)
+    sum_row = ["sum", balance_sum_str]
     if config.price:
-        sum_row.append(f"${round(usd_sum, config.round_ndigits)}")
+        usd_sum_str = fnumber(round(usd_sum, config.round_ndigits), config.format_number_separator, "$")
+        sum_row.append(usd_sum_str)
     rows.append(sum_row)
 
     if group.share < Decimal(1):
-        sum_share_row = [f"sum_share, {group.share}", round(balance_sum * group.share, config.round_ndigits)]
+        sum_share_str = fnumber(round(balance_sum * group.share, config.round_ndigits), config.format_number_separator)
+        sum_share_row = [f"sum_share, {group.share}", sum_share_str]
         if config.price:
-            sum_share_row.append(f"${round(usd_sum * group.share, config.round_ndigits)}")
+            usd_sum_share_str = fnumber(round(usd_sum * group.share, config.round_ndigits), config.format_number_separator, "$")
+            sum_share_row.append(usd_sum_share_str)
         rows.append(sum_share_row)
 
     table_headers = ["address", "balance"]
@@ -46,9 +59,25 @@ def _print_group(group: Group, group_balances: list[Balances.Balance], config: C
     print_table(group.name, table_headers, rows)
 
 
+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 = [[k, round(v, config.round_ndigits)] for (k, v) in prices.items()]
+        rows = []
+        for ticker, price in prices.items():
+            rows.append([ticker, fnumber(round(price, config.round_ndigits), config.format_number_separator, "$")])
         print_table("Prices", ["coin", "usd"], rows)
 
 
@@ -57,6 +86,17 @@ def print_total(config: Config, balances: Balances, prices: Prices) -> None:
     total.print()
 
 
+def print_errors(config: Config, balances: Balances) -> None:
+    error_balances = balances.get_errors()
+    if not error_balances:
+        return
+    rows = []
+    for balance in error_balances:
+        group = config.groups[balance.group_index]
+        rows.append([group.ticker + " / " + group.network, balance.address, balance.balance.err])  # type: ignore[union-attr]
+    print_table("Errors", ["coin", "address", "error"], rows)
+
+
 def create_progress_bar() -> Progress:
     return Progress(
         TextColumn("[progress.description]{task.description}"),

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/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/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)

mm_balance/rpc/solana.py

@@ -1,26 +1,26 @@
 from decimal import Decimal
 
-from mm_solana import balance, token
+from mm_solana import balance
+from mm_solana import token as solana_token
 from mm_std import Ok, Result
 
 from mm_balance.constants import RETRIES_BALANCE, RETRIES_DECIMALS, TIMEOUT_BALANCE, TIMEOUT_DECIMALS
 
 
-def get_native_balance(nodes: list[str], address: str, proxies: list[str], round_ndigits: int) -> Result[Decimal]:
-    return balance.get_balance_with_retries(
-        nodes, address, retries=RETRIES_BALANCE, timeout=TIMEOUT_BALANCE, proxies=proxies
-    ).and_then(lambda b: Ok(round(Decimal(b / 1_000_000_000), round_ndigits)))
-
-
-def get_token_balance(
-    nodes: list[str], wallet_address: str, token_address: str, decimals: int, proxies: list[str], round_ndigits: int
+def get_balance(
+    nodes: list[str], wallet: str, token: str | None, decimals: int, proxies: list[str], round_ndigits: int
 ) -> Result[Decimal]:
-    return token.get_balance_with_retries(
-        nodes, wallet_address, token_address, retries=RETRIES_BALANCE, timeout=TIMEOUT_BALANCE, proxies=proxies
-    ).and_then(lambda b: Ok(round(Decimal(b / 10**decimals), round_ndigits)))
+    if token is None:
+        res = balance.get_balance_with_retries(nodes, wallet, retries=RETRIES_BALANCE, timeout=TIMEOUT_BALANCE, proxies=proxies)
+    else:
+        res = solana_token.get_balance_with_retries(
+            nodes, wallet, token, retries=RETRIES_BALANCE, timeout=TIMEOUT_BALANCE, proxies=proxies
+        )
+
+    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 token.get_decimals_with_retries(
+    return solana_token.get_decimals_with_retries(
         nodes, token_address, retries=RETRIES_DECIMALS, timeout=TIMEOUT_DECIMALS, proxies=proxies
     )

mm_balance/token_decimals.py

@@ -1,37 +1,55 @@
 from mm_std import Err, fatal
 
 from mm_balance.config import Config
-from mm_balance.constants import Network
-from mm_balance.rpc import eth, solana
+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, int]]):
-    def __init__(self) -> None:
+class TokenDecimals(dict[Network, dict[str | None, int]]):  # {network: {None: 18}} -- None is for native token, ex. ETH
+    def __init__(self, networks: list[Network]) -> None:
         super().__init__()
-        for network in Network:
+        for network in networks:
             self[network] = {}
 
 
 def get_token_decimals(config: Config) -> TokenDecimals:
-    result = TokenDecimals()
+    result = TokenDecimals(config.networks())
+    proxies = config.proxies
 
     for group in config.groups:
-        if group.token_address is None or group.token_address in result[group.network]:
+        # token_decimals is already known
+        if group.token_decimals is not None:
+            result[group.network][group.token_address] = group.token_decimals
             continue
 
+        # get token_decimals for known native tokens
+        if group.token_address is None:
+            if group.network.is_evm_network():
+                result[group.network][None] = 18
+            elif group.network == NETWORK_SOLANA:
+                result[group.network][None] = 9
+            elif group.network == NETWORK_BITCOIN:
+                result[group.network][None] = 8
+            elif group.network == NETWORK_APTOS:
+                result[group.network][None] = 8
+            else:
+                fatal(f"Can't get token decimals for native token on network: {group.network}")
+            continue
+
+        # get token_decimals via RPC
+        # TODO: group.token_address must be in normalized form, otherwise it can be different for the same token
+        if group.token_address in result[group.network]:
+            continue  # don't request for a token_decimals twice
+
         nodes = config.nodes[group.network]
-        proxies = config.proxies
-
-        match group.network:
-            case Network.ETHEREUM:
-                decimals_res = eth.get_token_decimals(nodes, group.token_address, proxies)
-            case Network.SOLANA:
-                decimals_res = solana.get_token_decimals(nodes, group.token_address, proxies)
-            case _:
-                raise ValueError(f"unsupported network: {group.network}. Cant get token decimals for {group.token_address}")
-
-        if isinstance(decimals_res, Err):
-            fatal(f"can't get decimals for token {group.ticker} / {group.token_address}, error={decimals_res.err}")
-        result[group.network][group.token_address] = decimals_res.ok
+        if group.network.is_evm_network():
+            res = evm.get_token_decimals(nodes, group.token_address, proxies)
+        elif group.network == NETWORK_SOLANA:
+            res = solana.get_token_decimals(nodes, group.token_address, proxies)
+        else:
+            fatal(f"unsupported network: {group.network}. Cant get token decimals for {group.token_address}")
+        if isinstance(res, Err):
+            fatal(f"can't get decimals for token {group.ticker} / {group.token_address}, error={res.err}")
+        result[group.network][group.token_address] = res.ok
 
     return result

mm_balance/total.py

@@ -9,6 +9,7 @@ from mm_balance.balances import Balances
 from mm_balance.config import Config
 from mm_balance.constants import USD_STABLECOINS
 from mm_balance.price import Prices
+from mm_balance.utils import fnumber
 
 
 @dataclass
@@ -18,7 +19,7 @@ class Total:
     usd_sum: Decimal  # sum of all coins in USD
     usd_sum_share: Decimal
 
-    stablecoin_sum: Decimal  # sum of usd stablecoins: usdt, usdc
+    stablecoin_sum: Decimal  # sum of usd stablecoins: usdt, usdc, etc..
     stablecoin_sum_share: Decimal
 
     config: Config
@@ -53,7 +54,6 @@ class Total:
             coins_share=coins_share,
             usd_sum=usd_sum,
             usd_sum_share=usd_sum_share,
-            # usd_share=usd_share,
             stablecoin_sum=stablecoin_sum,
             stablecoin_sum_share=stablecoin_sum_share,
             config=config,
@@ -82,15 +82,21 @@ class Total:
                     usd_share = round(self.stablecoin_sum * 100 / self.usd_sum, self.config.round_ndigits)
                 else:
                     usd_share = round(usd_value * 100 / self.usd_sum, self.config.round_ndigits)
-                rows.append([key, value, f"${usd_value}", f"{usd_share}%"])
-            rows.append(["usd_sum", f"${self.usd_sum}"])
+
+                value_str = fnumber(value, self.config.format_number_separator)
+                usd_value_str = fnumber(usd_value, self.config.format_number_separator, "$")
+
+                rows.append([key, value_str, usd_value_str, f"{usd_share}%"])
+
+            rows.append(["stablecoin_sum", fnumber(self.stablecoin_sum, self.config.format_number_separator, "$")])
+            rows.append(["usd_sum", fnumber(self.usd_sum, self.config.format_number_separator, "$")])
             print_table("Total", ["coin", "balance", "usd", "usd_share"], rows)
 
     def _print_total_total_without_price(self) -> None:
         if self.config.print_format == PrintFormat.TABLE:
             rows = []
             for key, value in self.coins.items():
-                rows.append([key, value])
+                rows.append([key, fnumber(value, self.config.format_number_separator)])
             print_table("Total", ["coin", "balance"], rows)
 
     def _print_share_total_with_price(self) -> None:
@@ -101,12 +107,16 @@ class Total:
                 usd_share = round(self.stablecoin_sum_share * 100 / self.usd_sum_share, self.config.round_ndigits)
             else:
                 usd_share = round(usd_value * 100 / self.usd_sum_share, self.config.round_ndigits)
-            rows.append([key, self.coins_share[key], f"${usd_value}", f"{usd_share}%"])
-        rows.append(["usd_sum", f"${self.usd_sum_share}"])
+            value = fnumber(self.coins_share[key], self.config.format_number_separator)
+            usd_value_str = fnumber(usd_value, self.config.format_number_separator, "$")
+            rows.append([key, value, usd_value_str, f"{usd_share}%"])
+        rows.append(["stablecoin_sum", fnumber(self.stablecoin_sum_share, self.config.format_number_separator, "$")])
+        rows.append(["usd_sum", fnumber(self.usd_sum_share, self.config.format_number_separator, "$")])
         print_table("Total, share", ["coin", "balance", "usd", "usd_share"], rows)
 
     def _print_share_total_without_price(self) -> None:
         rows = []
         for key, _ in self.coins.items():
-            rows.append([key, self.coins_share[key]])
+            value = fnumber(self.coins_share[key], self.config.format_number_separator)
+            rows.append([key, value])
         print_table("Total, share", ["coin", "balance"], rows)

mm_balance/utils.py

@@ -0,0 +1,10 @@
+from decimal import Decimal
+
+
+def fnumber(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

{mm_balance-0.1.12.dist-info → mm_balance-0.1.14.dist-info}/METADATA

@@ -1,8 +1,9 @@
 Metadata-Version: 2.3
 Name: mm-balance
-Version: 0.1.12
+Version: 0.1.14
 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.4
+Requires-Dist: mm-solana==0.1.5
 Requires-Dist: typer>=0.12.5

mm_balance-0.1.14.dist-info/RECORD

@@ -0,0 +1,20 @@
+mm_balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_balance/balances.py,sha256=HLIMdhayd59SIjzaYPwJek4PvwGnpTESvUt8SoF1Ktc,3812
+mm_balance/cli.py,sha256=AIIxj7msKD3d5vr6mTT5x-D3-AD7JyU4sxoNCI3Uozk,1887
+mm_balance/config.py,sha256=5qOsU1JjWu2TbH1VgikK4oZpBcuPMqsOe8DOwMRtrWM,5230
+mm_balance/constants.py,sha256=4C2BxYRY_i83Rba5NOXeLLeA0ZTWR9WD6BeyQwiCj_U,2335
+mm_balance/output.py,sha256=ZkYh0gU32OAJIoXz2ExG44ong9mzAgohU9SG3rn3yqg,4281
+mm_balance/price.py,sha256=f6fYhpPVqZE9hH22ypfYb9m-nfE41LeVIvksEvqmz54,1615
+mm_balance/token_decimals.py,sha256=WAz9wbvwjPJEcQnrLyPAf23eGp89t9oP_xBmaEecEG0,2348
+mm_balance/total.py,sha256=FrORCE3_gW9tMh8UCgqLcHK15wQuwOwX3Fp6QhaRrgY,5504
+mm_balance/utils.py,sha256=YjQMfyAaLiiprjt9CuNbDQSJrLbRoTkb2rurAb6bHDc,288
+mm_balance/config/example.yml,sha256=EMWgogMkdxDUkBKDcDStbsCR-fnUD6SFYgCdfl7S2yg,1859
+mm_balance/rpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_balance/rpc/aptos.py,sha256=6hKGKTs2DPQMa4RmPXzfvjCFjPjN8wjJhRRI6HdI9GM,628
+mm_balance/rpc/btc.py,sha256=ugp90H7YW0kiXIh98bQWk9mQTW20yE-jBiCpRvfoH-U,481
+mm_balance/rpc/evm.py,sha256=ewlMmRrcXKlky3DPNbnUBTVwnvyw7N9iCZLsCX2V14w,1007
+mm_balance/rpc/solana.py,sha256=Lwl5Otqy48g4LWfz9uN7_rkICKUIYJvf88PbIAnfMdc,1051
+mm_balance-0.1.14.dist-info/METADATA,sha256=kZgluU7iJnTzbuLyh-NDAgKOuy0H-5QCzguVia3jQFM,229
+mm_balance-0.1.14.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+mm_balance-0.1.14.dist-info/entry_points.txt,sha256=rSnP0ZW1a3ACNwTWM7T53CmOycKbzhG43m2_wseENng,50
+mm_balance-0.1.14.dist-info/RECORD,,

mm_balance/rpc/eth.py

@@ -1,31 +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
-
-
-def get_native_balance(nodes: list[str], address: str, proxies: list[str], round_ndigits: int) -> Result[Decimal]:
-    return rpc.eth_get_balance(nodes, address, proxies=proxies, attempts=RETRIES_BALANCE, timeout=TIMEOUT_BALANCE).and_then(
-        lambda b: Ok(round(Decimal(b / 10**18), round_ndigits)),
-    )
-
-
-def get_token_balance(
-    nodes: list[str], wallet_address: str, token_address: str, decimals: int, proxies: list[str], round_ndigits: int
-) -> Result[Decimal]:
-    return erc20.get_balance(
-        nodes,
-        token_address,
-        wallet_address,
-        proxies=proxies,
-        attempts=RETRIES_BALANCE,
-        timeout=TIMEOUT_BALANCE,
-    ).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)

mm_balance-0.1.12.dist-info/RECORD

@@ -1,18 +0,0 @@
-mm_balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_balance/balances.py,sha256=4PjyxEynkv_59cs6-HujU3rn18DebotnWIu8Sa1Jj9s,3662
-mm_balance/cli.py,sha256=GZB3MgYxOV5AWhX2NvU9LWKF7I2iNQzyhgC2oKlOODU,1700
-mm_balance/config.py,sha256=I1QmL5Nlyyifn78wmndnw5zi-zk_B-paK42KTd4pRb4,4995
-mm_balance/constants.py,sha256=J0N8GmWAagKGyJ8DMnmxhU6LXEkvKhYiJpacKqxkQ4s,1308
-mm_balance/output.py,sha256=5y35jJUDJqrz86EVNklBVa06b1ia0ppy2ypTy9Jkbb0,2570
-mm_balance/price.py,sha256=wlClQNW03BSzq8gxQxH9f5LnwRFZBqeI-tfY9vtlSJE,2005
-mm_balance/token_decimals.py,sha256=iNhAEEPfg8MvjxBGnFdxh82pYg3v26w4s9xro2Emoi8,1307
-mm_balance/total.py,sha256=PERRR9m77LBgu30tUEdyfGdtmVDFa-dICq8S9zcH1eA,4716
-mm_balance/config/example.yml,sha256=KxSmjIKY1LXjUzfA4sv3j352fVePRDEeqG48xEwKWkc,1482
-mm_balance/rpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_balance/rpc/btc.py,sha256=ugp90H7YW0kiXIh98bQWk9mQTW20yE-jBiCpRvfoH-U,481
-mm_balance/rpc/eth.py,sha256=G7aYjTw6xJwcsAyIp9eVW8NRVDUGeTCpdbd-CqgqHyw,1167
-mm_balance/rpc/solana.py,sha256=vmCAaeQKwxg95qdSmUEjFS9bAPUJVx8irtWv6nlRBvU,1174
-mm_balance-0.1.12.dist-info/METADATA,sha256=fYBCpx8m2vk02CTT-tJskdEZoi_wZkBdXc8cprDU4_8,198
-mm_balance-0.1.12.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-mm_balance-0.1.12.dist-info/entry_points.txt,sha256=rSnP0ZW1a3ACNwTWM7T53CmOycKbzhG43m2_wseENng,50
-mm_balance-0.1.12.dist-info/RECORD,,