mm-balance 0.1.9__tar.gz → 0.1.11__tar.gz

{mm_balance-0.1.9 → mm_balance-0.1.11}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: mm-balance
-Version: 0.1.9
+Version: 0.1.11
 Requires-Python: >=3.12
 Requires-Dist: mm-btc==0.1.0
 Requires-Dist: mm-eth==0.1.3
-Requires-Dist: mm-solana==0.1.2
+Requires-Dist: mm-solana==0.1.4
 Requires-Dist: typer>=0.12.5

{mm_balance-0.1.9 → mm_balance-0.1.11}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "mm-balance"
-version = "0.1.9"
+version = "0.1.11"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
     "mm-btc==0.1.0",
     "mm-eth==0.1.3",
-    "mm-solana==0.1.2",
+    "mm-solana==0.1.4",
     "typer>=0.12.5",
 ]
 [project.scripts]
@@ -21,11 +21,11 @@ dev-dependencies = [
     "pytest~=8.3.3",
     "pytest-xdist~=3.6.1",
     "pytest-httpserver~=1.1.0",
-    "coverage~=7.6.0",
+    "coverage~=7.6.3",
     "ruff~=0.6.9",
     "pip-audit~=2.7.0",
     "bandit~=1.7.10",
-    "mypy~=1.11.2",
+    "mypy~=1.12.0",
     "types-python-dateutil~=2.9.0.20241003",
     "types-PyYAML~=6.0.12.20240917",
 ]
@@ -56,7 +56,8 @@ lint.ignore = [
     "A003", # builtin-attribute-shadowing
     #    "B008", # function-call-argument-default
     "UP040", # non-pep695-type-alias
-    "COM812"
+    "COM812",
+    "RUF012"
 ]
 
 [tool.bandit]

mm_balance-0.1.11/src/mm_balance/balances.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from decimal import Decimal
+
+from mm_std import ConcurrentTasks, Result
+from pydantic import BaseModel
+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.token_decimals import TokenDecimals
+
+
+class Balances:
+    class Balance(BaseModel):
+        group_index: int
+        address: str
+        token_address: str | None
+        balance: Result[Decimal] | None = None
+
+    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.progress_bar = output.create_progress_bar()
+        self.progress_bar_task: dict[Network, TaskID] = {}
+
+        for idx, group in enumerate(config.groups):
+            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:
+            self.progress_bar_task[network] = output.create_progress_task(
+                self.progress_bar, network.value, 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,))
+            job.execute()
+
+    def _process_network(self, network: Network) -> None:
+        job = ConcurrentTasks(max_workers=self.config.workers[network])
+        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()
+        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.round_ndigits
+        proxies = self.config.proxies
+        token_decimals = self.token_decimals[network][token_address] if token_address else -1
+        match network:
+            case Network.BTC:
+                res = btc.get_balance(wallet_address, proxies, round_ndigits)
+            case Network.ETH:
+                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.SOL:
+                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)
+
+            case _:
+                raise ValueError
+
+        self.progress_bar.update(self.progress_bar_task[network], advance=1)
+        return res
+
+    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]
+
+
+# class Balances2(BaseModel):
+#     class Balance(BaseModel):
+#         group_index: int
+#         address: str
+#         token_address: str | None
+#         balance: Result[Decimal] | None = None
+#
+#     config: Config
+#     token_decimals: TokenDecimals
+#     # separate balance tasks on networks
+#     btc: list[Balance]
+#     eth: list[Balance]
+#     sol: list[Balance]
+#
+#     def network_tasks(self, network: Network) -> list[Balance]:
+#         if network == Network.BTC:
+#             return self.btc
+#         elif network == Network.ETH:
+#             return self.eth
+#         elif network == Network.SOL:
+#             return self.sol
+#         else:
+#             raise ValueError
+#
+#     def get_group_balances(self, group_index: int, network: Network) -> list[Balance]:
+#         # TODO: can we get network by group_index?
+#         if network == Network.BTC:
+#             network_balances = self.btc
+#         elif network == Network.ETH:
+#             network_balances = self.eth
+#         elif network == Network.SOL:
+#             network_balances = self.sol
+#         else:
+#             raise ValueError
+#
+#         return [b for b in network_balances if b.group_index == group_index]
+#
+#     def process(self) -> None:
+#         progress = output.create_progress_bar()
+#         task_btc = output.create_progress_task(progress, "btc", len(self.btc))
+#         task_eth = output.create_progress_task(progress, "eth", len(self.eth))
+#         task_sol = output.create_progress_task(progress, "sol", len(self.sol))
+#         with progress:
+#             job = ConcurrentTasks()
+#             job.add_task("btc", self._process_btc, args=(progress, task_btc))
+#             job.add_task("eth", self._process_eth, args=(progress, task_eth))
+#             job.add_task("sol", self._process_sol, args=(progress, task_sol))
+#             job.execute()
+#
+#     def _process_btc(self, progress: Progress, task_id: TaskID) -> None:
+#         job = ConcurrentTasks(max_workers=self.config.workers.btc)
+#         for idx, task in enumerate(self.btc):
+#             job.add_task(str(idx), btc.get_balance, args=(task.address, self.config, progress, task_id))
+#         job.execute()
+#         for idx, _task in enumerate(self.btc):
+#             self.btc[idx].balance = job.result.get(str(idx))  # type: ignore[assignment]
+#
+#     def _process_eth(self, progress: Progress, task_id: TaskID) -> None:
+#         job = ConcurrentTasks(max_workers=self.config.workers.eth)
+#         for idx, task in enumerate(self.eth):
+#             job.add_task(str(idx), self._get_balance,
+#                          args=(Network.ETH, task.address, task.token_address, self.config, progress, task_id))
+#         job.execute()
+#         for idx, _task in enumerate(self.eth):
+#             self.eth[idx].balance = job.result.get(str(idx))  # type: ignore[assignment]
+#
+#     def _process_sol(self, progress: Progress, task_id: TaskID) -> None:
+#         job = ConcurrentTasks(max_workers=self.config.workers.sol)
+#         for idx, task in enumerate(self.sol):
+#             job.add_task(str(idx), solana.get_balance, args=(task.address, self.config, progress, task_id))
+#         job.execute()
+#         for idx, _task in enumerate(self.sol):
+#             self.sol[idx].balance = job.result.get(str(idx))  # type: ignore[assignment]
+#
+#     @staticmethod
+#     def from_config(config: Config, token_decimals: TokenDecimals) -> Balances:
+#         tasks = Balances(config=config, btc=[], eth=[], sol=[], token_decimals=token_decimals)
+#         for idx, group in enumerate(config.groups):
+#             task_list = [Balances.Balance(group_index=idx, address=a, token_address=group.token_address) for a in group.addresses] # noqa
+#             if group.network == Network.BTC:
+#                 tasks.btc.extend(task_list)
+#             elif group.network == Network.ETH:
+#                 tasks.eth.extend(task_list)
+#             elif group.network == Network.SOL:
+#                 tasks.sol.extend(task_list)
+#         return tasks

{mm_balance-0.1.9 → mm_balance-0.1.11}/src/mm_balance/cli.py

@@ -9,6 +9,7 @@ from mm_balance import output
 from mm_balance.balances import Balances
 from mm_balance.config import Config
 from mm_balance.price import Prices, get_prices
+from mm_balance.token_decimals import get_token_decimals
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
@@ -31,10 +32,12 @@ def cli(
     config = Config.read_config(config_path, zip_password=zip_password)
 
     prices = get_prices(config) if config.price else Prices()
-    balances = Balances.from_config(config)
+    output.print_prices(config, prices)
+
+    token_decimals = get_token_decimals(config)
+    balances = Balances(config, token_decimals)
     balances.process()
 
-    output.print_prices(config, prices)
     output.print_groups(balances, config, prices)
     output.print_total(config, balances, prices)
 

{mm_balance-0.1.9 → mm_balance-0.1.11}/src/mm_balance/config/example.yml

@@ -1,8 +1,13 @@
-groups:
+coins:
   - coin: sol
     addresses:
       - 2ojv9BAiHUrvsm9gxDe7fJSzbNZSJcxZvf8dqmWGHG8S # binance
 
+  - coin: usdt
+    network: sol
+    addresses:
+      - 2ojv9BAiHUrvsm9gxDe7fJSzbNZSJcxZvf8dqmWGHG8S # binance
+
   - coin: btc
     comment: coldwallets
     addresses: |
@@ -48,4 +53,4 @@ addresses:
 #- http://123.123.123.123
 #- http://123.123.123.124
 #round_ndigits: 4
-#price: no
+#price: yes

mm_balance-0.1.11/src/mm_balance/config.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any, 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_ETH_NODES, DEFAULT_SOL_NODES, EthTokenAddress, Network, SolTokenAddress
+
+
+class Group(BaseConfig):
+    comment: str = ""
+    coin: str
+    network: Network
+    token_address: str | None = None
+    coingecko_id: str | None = None
+    addresses: list[str] = Field(default_factory=list)
+    share: Decimal = Decimal(1)
+
+    @property
+    def name(self) -> str:
+        result = self.coin
+        if self.comment:
+            result += " / " + self.comment
+        return result
+
+    @field_validator("coin", mode="after")
+    def coin_validator(cls, v: str) -> str:
+        return v.upper()
+
+    @field_validator("addresses", mode="before")
+    def to_list_validator(cls, v: str | list[str] | None) -> list[str]:
+        return cls.to_list_str_validator(v, unique=True, remove_comments=True, split_line=True)
+
+    @model_validator(mode="before")
+    def before_all(cls, data: Any) -> Any:
+        if "network" not in data:
+            data["network"] = detect_network(data["coin"])
+        return data
+
+    @model_validator(mode="after")
+    def final_validator(self) -> Self:
+        if self.token_address is None:
+            self.token_address = detect_token_address(self.coin, self.network)
+        if self.token_address is not None and self.network is Network.ETH:
+            self.token_address = self.token_address.lower()
+        return self
+
+    def process_addresses(self, address_groups: list[AddressGroup]) -> None:
+        addresses: list[str] = []
+        for address in self.addresses:
+            if address_group := pydash.find(address_groups, lambda g: g.name == address):  # noqa: B023
+                addresses.extend(address_group.addresses)
+            else:
+                # TODO: check address is valid
+                addresses.append(address)
+        self.addresses = addresses
+
+
+class AddressGroup(BaseConfig):
+    name: str
+    addresses: list[str]
+
+    @field_validator("addresses", mode="before")
+    def to_list_validator(cls, v: str | list[str] | None) -> list[str]:
+        return cls.to_list_str_validator(v, unique=True, remove_comments=True, split_line=True)
+
+
+class Config(BaseConfig):
+    groups: list[Group] = Field(alias="coins")
+    addresses: list[AddressGroup] = Field(default_factory=list)
+
+    proxies_url: str | None = None
+    proxies: list[str] = Field(default_factory=list)
+    round_ndigits: int = 4
+    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}
+
+    def has_share(self) -> bool:
+        return any(g.share != Decimal(1) for g in self.groups)
+
+    @model_validator(mode="after")
+    def final_validator(self) -> Self:
+        # load from proxies_url
+        if self.proxies_url is not None:
+            self.proxies = get_proxies(self.proxies_url)
+
+        # load addresses from address_group
+        for group in self.groups:
+            group.process_addresses(self.addresses)
+
+        # load default rpc nodes
+        if Network.BTC not in self.nodes:
+            self.nodes[Network.BTC] = []
+        if Network.ETH not in self.nodes:
+            self.nodes[Network.ETH] = DEFAULT_ETH_NODES
+        if Network.SOL not in self.nodes:
+            self.nodes[Network.SOL] = DEFAULT_SOL_NODES
+
+        return self
+
+
+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}")
+
+
+def detect_token_address(coin: str, network: str) -> str | None:
+    if network == Network.ETH.lower():
+        if coin.lower() == "usdt":
+            return EthTokenAddress.USDT
+        if coin.lower() == "usdc":
+            return EthTokenAddress.USDC
+
+    if network == Network.SOL.lower():
+        if coin.lower() == "usdt":
+            return SolTokenAddress.USDT
+        if coin.lower() == "usdc":
+            return SolTokenAddress.USDC
+
+
+def get_proxies(proxies_url: str) -> list[str]:
+    try:
+        res = hr(proxies_url)
+        if res.is_error():
+            fatal(f"Can't get proxies: {res.error}")
+        proxies = [p.strip() for p in res.body.splitlines() if p.strip()]
+        return pydash.uniq(proxies)
+    except Exception as err:
+        fatal(f"Can't get  proxies: {err}")
+
+
+def get_address_group_by_name(address_groups: list[AddressGroup], name: str) -> AddressGroup | None:
+    return pydash.find(address_groups, lambda g: g.name == name)

mm_balance-0.1.9/src/mm_balance/types.py → mm_balance-0.1.11/src/mm_balance/constants.py

@@ -2,6 +2,25 @@ from __future__ import annotations
 
 from enum import Enum, unique
 
+RETRIES_BALANCE = 5
+RETRIES_DECIMALS = 5
+RETRIES_COINGECKO_PRICES = 5
+TIMEOUT_BALANCE = 5
+TIMEOUT_DECIMALS = 5
+
+
+@unique
+class EthTokenAddress(str, Enum):
+    USDT = "0xdac17f958d2ee523a2206206994597c13d831ec7"
+    USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+
+
+@unique
+class SolTokenAddress(str, Enum):
+    USDT = "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
+    USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+
+
 DEFAULT_ETH_NODES = ["https://ethereum.publicnode.com", "https://rpc.ankr.com/eth"]
 DEFAULT_SOL_NODES = ["https://api.mainnet-beta.solana.com"]
 
@@ -24,9 +43,3 @@ class Network(str, Enum):
     BTC = "btc"
     ETH = "eth"
     SOL = "sol"
-
-
-@unique
-class EthTokenAddress(str, Enum):
-    USDT = "0xdac17f958d2ee523a2206206994597c13d831ec7"
-    USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"

{mm_balance-0.1.9 → mm_balance-0.1.11}/src/mm_balance/output.py

@@ -4,7 +4,7 @@ from mm_std import Ok, print_table
 from rich.progress import BarColumn, MofNCompleteColumn, Progress, TaskID, TextColumn
 
 from mm_balance.balances import Balances
-from mm_balance.config import Config
+from mm_balance.config import Config, Group
 from mm_balance.price import Prices
 from mm_balance.total import Total
 
@@ -15,7 +15,7 @@ def print_groups(balances: Balances, config: Config, prices: Prices) -> None:
         _print_group(group, group_balances, config, prices)
 
 
-def _print_group(group: Config.Group, group_balances: list[Balances.Balance], config: Config, prices: Prices) -> None:
+def _print_group(group: Group, group_balances: list[Balances.Balance], config: Config, prices: Prices) -> None:
     rows = []
     balance_sum = Decimal(0)
     usd_sum = Decimal(0)

mm_balance-0.1.11/src/mm_balance/price.py

@@ -0,0 +1,55 @@
+from decimal import Decimal
+
+import pydash
+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, EthTokenAddress, Network
+
+
+class Prices(dict[str, Decimal]):
+    """
+    A Prices class representing a mapping from coin names to their prices.
+
+    Inherits from:
+        Dict[str, Decimal]: A dictionary with coin names as keys and their prices as Decimal values.
+    """
+
+
+def get_prices(config: Config) -> Prices:
+    result = Prices()
+
+    coins = pydash.uniq([group.coin for group in config.groups])
+    coingecko_ids = pydash.uniq([get_coingecko_id(group) for group in config.groups])
+
+    url = f"https://api.coingecko.com/api/v3/simple/price?ids={",".join(coingecko_ids)}&vs_currencies=usd"
+    for _ in range(RETRIES_COINGECKO_PRICES):
+        res = hr(url, proxy=random_str_choice(config.proxies))
+        if res.code != 200:
+            continue
+
+        for idx, coin in enumerate(coins):
+            if coingecko_ids[idx] in res.json:
+                result[coin] = Decimal(str(pydash.get(res.json, f"{coingecko_ids[idx]}.usd")))
+            else:
+                fatal("Can't get price for {coin} from coingecko, coingecko_id={coingecko_ids[idx]}")
+
+    return result
+
+
+def get_coingecko_id(group: Group) -> str:
+    if group.coingecko_id:
+        return group.coingecko_id
+    elif group.network is Network.BTC:
+        return "bitcoin"
+    elif group.network is Network.ETH and group.token_address is None:
+        return "ethereum"
+    elif group.coin.lower() == "usdt" or (group.token_address is not None and group.token_address == EthTokenAddress.USDT):
+        return "tether"
+    elif group.coin.lower() == "usdc" or (group.token_address is not None and group.token_address == EthTokenAddress.USDC):
+        return "usd-coin"
+    elif group.coin.lower() == "sol":
+        return "solana"
+
+    raise ValueError(f"can't get coingecko_id for {group.coin}")

mm_balance-0.1.11/src/mm_balance/rpc/btc.py

@@ -0,0 +1,16 @@
+from decimal import Decimal
+
+from mm_btc.blockstream import BlockstreamClient
+from mm_std import Ok, Result
+
+from mm_balance.constants import RETRIES_BALANCE
+
+
+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(round(Decimal(b / 100_000_000), round_ndigits)),
+        )
+    )

mm_balance-0.1.11/src/mm_balance/rpc/eth.py

@@ -0,0 +1,31 @@
+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.11/src/mm_balance/rpc/solana.py

@@ -0,0 +1,26 @@
+from decimal import Decimal
+
+from mm_solana import balance, 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
+) -> 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)))
+
+
+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.1.11/src/mm_balance/token_decimals.py

@@ -0,0 +1,37 @@
+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
+
+
+class TokenDecimals(dict[Network, dict[str, int]]):
+    def __init__(self) -> None:
+        super().__init__()
+        for network in Network:
+            self[network] = {}
+
+
+def get_token_decimals(config: Config) -> TokenDecimals:
+    result = TokenDecimals()
+
+    for group in config.groups:
+        if group.token_address is None or group.token_address in result[group.network]:
+            continue
+
+        nodes = config.nodes[group.network]
+        proxies = config.proxies
+
+        match group.network:
+            case Network.ETH:
+                decimals_res = eth.get_token_decimals(nodes, group.token_address, proxies)
+            case Network.SOL:
+                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.coin} / {group.token_address}, error={decimals_res.err}")
+        result[group.network][group.token_address] = decimals_res.ok
+
+    return result

{mm_balance-0.1.9 → mm_balance-0.1.11}/src/mm_balance/total.py

@@ -7,15 +7,14 @@ from mm_std import Ok, PrintFormat, print_table
 
 from mm_balance.balances import Balances
 from mm_balance.config import Config
+from mm_balance.constants import Coin
 from mm_balance.price import Prices
-from mm_balance.types import Coin
 
 
 @dataclass
 class Total:
     coins: dict[str, Decimal]
     coins_share: dict[str, Decimal]
-    # usd_share: dict[str, Decimal]  # all stablecoins have key 'usd'
     usd_sum: Decimal  # sum of all coins in USD
     usd_sum_share: Decimal
 
@@ -29,7 +28,6 @@ class Total:
     def calc(cls, balances: Balances, prices: Prices, config: Config) -> Self:
         coins: dict[str, Decimal] = defaultdict(Decimal)
         coins_share: dict[str, Decimal] = defaultdict(Decimal)
-        # usd_share: dict[str, Decimal] = defaultdict(Decimal)
         usd_sum = Decimal(0)
         usd_sum_share = Decimal(0)
 
@@ -37,7 +35,6 @@ class Total:
         stablecoin_sum_share = Decimal(0)
         for group_index, group in enumerate(config.groups):
             balance_sum = Decimal(0)
-            # for address_task in [t for t in tasks.network_tasks(group.network) if t.group_index == group_index]:
             for address_task in balances.get_group_balances(group_index, group.network):
                 if isinstance(address_task.balance, Ok):
                     balance_sum += address_task.balance.ok