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

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: mm-balance
-Version: 0.1.11
+Version: 0.1.13
 Requires-Python: >=3.12
 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.11 → mm_balance-0.1.13}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "mm-balance"
-version = "0.1.11"
+version = "0.1.13"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
     "mm-btc==0.1.0",
     "mm-eth==0.1.3",
-    "mm-solana==0.1.4",
+    "mm-solana==0.1.5",
     "typer>=0.12.5",
 ]
 [project.scripts]

mm_balance-0.1.13/src/mm_balance/balances.py

@@ -0,0 +1,90 @@
+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:
+            if self.tasks[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.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)
+
+            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]
+
+    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-0.1.11 → mm_balance-0.1.13}/src/mm_balance/cli.py

@@ -8,6 +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.price import Prices, get_prices
 from mm_balance.token_decimals import get_token_decimals
 
@@ -21,10 +22,20 @@ def example_callback(value: bool) -> None:
         raise typer.Exit
 
 
+def networks_callback(value: bool) -> None:
+    if value:
+        for network in Network:
+            typer.echo(network)
+        raise typer.Exit
+
+
 @app.command()
 def cli(
     config_path: Annotated[pathlib.Path, typer.Argument()],
     _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"):
@@ -40,6 +51,7 @@ def cli(
 
     output.print_groups(balances, config, prices)
     output.print_total(config, balances, prices)
+    output.print_errors(config, balances)
 
 
 if __name__ == "__main__":

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

@@ -1,14 +1,16 @@
 coins:
-  - coin: sol
+  - ticker: SOL
+    network: solana
     addresses:
       - 2ojv9BAiHUrvsm9gxDe7fJSzbNZSJcxZvf8dqmWGHG8S # binance
 
-  - coin: usdt
-    network: sol
+  - ticker: USDT
+    network: solana
     addresses:
       - 2ojv9BAiHUrvsm9gxDe7fJSzbNZSJcxZvf8dqmWGHG8S # binance
 
-  - coin: btc
+  - ticker: BTC
+    network: bitcoin
     comment: coldwallets
     addresses: |
       34xp4vRoCGJym3xR7yCVPFHoCNxv4Twseo # binance
@@ -16,19 +18,23 @@ coins:
       bc1ql49ydapnjafl5t2cp9zqpjwe6pdgmxy98859v2 # robinhood
     share: 0.1 # 10%
 
-  - coin: eth
+  - ticker: ETH
+    network: ethereum
     comment: okx
     addresses: okx_eth
 
-  - coin: usdt
+  - ticker: USDT
+    network: ethereum
     comment: okx
     addresses: okx_eth
 
-  - coin: eth
+  - ticker: ETH
+    network: ethereum
     comment: binance
     addresses: binance_eth
 
-  - coin: usdt
+  - ticker: USDT
+    network: ethereum
     comment: binance
     addresses: binance_eth
 
@@ -54,3 +60,4 @@ addresses:
 #- http://123.123.123.124
 #round_ndigits: 4
 #price: yes
+#skip_empty: no

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

@@ -1,18 +1,19 @@
 from __future__ import annotations
 
 from decimal import Decimal
-from typing import Any, Self
+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_ETH_NODES, DEFAULT_SOL_NODES, EthTokenAddress, Network, SolTokenAddress
+from mm_balance.constants import DEFAULT_NODES, TOKEN_ADDRESS, Network
 
 
 class Group(BaseConfig):
     comment: str = ""
-    coin: str
+    ticker: str
     network: Network
     token_address: str | None = None
     coingecko_id: str | None = None
@@ -21,30 +22,31 @@ class Group(BaseConfig):
 
     @property
     def name(self) -> str:
-        result = self.coin
+        result = self.ticker
         if self.comment:
             result += " / " + self.comment
+        result += " / " + self.network.value
         return result
 
-    @field_validator("coin", mode="after")
-    def coin_validator(cls, v: str) -> str:
+    @field_validator("ticker", mode="after")
+    def ticker_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="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 = detect_token_address(self.ticker, self.network)
+        if self.token_address is not None and self.network is Network.ETHEREUM:
             self.token_address = self.token_address.lower()
         return self
 
@@ -56,7 +58,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):
@@ -78,6 +80,7 @@ class Config(BaseConfig):
     nodes: dict[Network, list[str]] = Field(default_factory=dict)
     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}
 
@@ -95,40 +98,16 @@ class Config(BaseConfig):
             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
+        for network in Network:
+            if network not in self.nodes:
+                self.nodes[network] = DEFAULT_NODES[network]
 
         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 detect_token_address(ticker: str, network: Network) -> str | None:
+    if network in TOKEN_ADDRESS:
+        return TOKEN_ADDRESS[network].get(ticker)
 
 
 def get_proxies(proxies_url: str) -> list[str]:
@@ -144,3 +123,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-0.1.13/src/mm_balance/constants.py

@@ -0,0 +1,56 @@
+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 Network(str, Enum):
+    ARBITRUM_ONE = "arbitrum-one"
+    BITCOIN = "bitcoin"
+    ETHEREUM = "ethereum"
+    SOLANA = "solana"
+    OP_MAINNET = "op-mainnet"  # Optimism 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",
+}
+
+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"],
+}

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

@@ -20,11 +20,13 @@ 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:
+        if config.skip_empty and isinstance(address_task.balance, Ok) and address_task.balance.ok == Decimal(0):
+            continue
         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 config.price:
-                balance_usd = round(address_task.balance.ok * prices[group.coin], config.round_ndigits)
+                balance_usd = round(address_task.balance.ok * prices[group.ticker], config.round_ndigits)
                 usd_sum += balance_usd
                 row.append(f"${balance_usd}")
         rows.append(row)
@@ -57,6 +59,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-0.1.11 → mm_balance-0.1.13}/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, EthTokenAddress, Network
+from mm_balance.constants import RETRIES_COINGECKO_PRICES, Network
 
 
 class Prices(dict[str, Decimal]):
@@ -20,7 +20,7 @@ class Prices(dict[str, Decimal]):
 def get_prices(config: Config) -> Prices:
     result = Prices()
 
-    coins = pydash.uniq([group.coin for group in config.groups])
+    coins = pydash.uniq([group.ticker 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"
@@ -38,18 +38,29 @@ 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.BTC:
+    elif group.network is Network.BITCOIN:
         return "bitcoin"
-    elif group.network is Network.ETH and group.token_address is None:
+    elif group.network is Network.ETHEREUM and group.token_address is None:
+        return "ethereum"
+    elif group.ticker == "ETH":
         return "ethereum"
-    elif group.coin.lower() == "usdt" or (group.token_address is not None and group.token_address == EthTokenAddress.USDT):
+    elif group.ticker == "USDT":
         return "tether"
-    elif group.coin.lower() == "usdc" or (group.token_address is not None and group.token_address == EthTokenAddress.USDC):
+    elif group.ticker == "USDC":
         return "usd-coin"
-    elif group.coin.lower() == "sol":
+    elif group.ticker == "SOL":
         return "solana"
 
-    raise ValueError(f"can't get coingecko_id for {group.coin}")
+    raise ValueError(f"can't get coingecko_id for {group.ticker}")

{mm_balance-0.1.11 → mm_balance-0.1.13}/src/mm_balance/token_decimals.py

@@ -23,15 +23,15 @@ def get_token_decimals(config: Config) -> TokenDecimals:
         proxies = config.proxies
 
         match group.network:
-            case Network.ETH:
+            case Network.ETHEREUM:
                 decimals_res = eth.get_token_decimals(nodes, group.token_address, proxies)
-            case Network.SOL:
+            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.coin} / {group.token_address}, error={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
 
     return result

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

@@ -7,7 +7,7 @@ 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.constants import USD_STABLECOINS
 from mm_balance.price import Prices
 
 
@@ -38,16 +38,16 @@ class Total:
             for address_task in balances.get_group_balances(group_index, group.network):
                 if isinstance(address_task.balance, Ok):
                     balance_sum += address_task.balance.ok
-                    if group.coin in Coin.usd_coins():
+                    if group.ticker in USD_STABLECOINS:
                         stablecoin_sum += address_task.balance.ok
                         stablecoin_sum_share += address_task.balance.ok * group.share
                     if config.price:
-                        balance_usd = round(address_task.balance.ok * prices[group.coin], config.round_ndigits)
+                        balance_usd = round(address_task.balance.ok * prices[group.ticker], config.round_ndigits)
                         usd_sum += balance_usd
                         usd_sum_share += group.share * balance_usd
 
-            coins[group.coin] += balance_sum
-            coins_share[group.coin] += round(balance_sum * group.share, config.round_ndigits)
+            coins[group.ticker] += balance_sum
+            coins_share[group.ticker] += round(balance_sum * group.share, config.round_ndigits)
         return cls(
             coins=coins,
             coins_share=coins_share,
@@ -78,7 +78,7 @@ class Total:
             rows = []
             for key, value in self.coins.items():
                 usd_value = round(value * self.prices[key], self.config.round_ndigits)
-                if key in Coin.usd_coins():
+                if key in USD_STABLECOINS:
                     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)
@@ -97,7 +97,7 @@ class Total:
         rows = []
         for key, _ in self.coins.items():
             usd_value = round(self.coins_share[key] * self.prices[key], self.config.round_ndigits)
-            if key in Coin.usd_coins():
+            if key in USD_STABLECOINS:
                 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)

{mm_balance-0.1.11 → mm_balance-0.1.13}/uv.lock

@@ -925,7 +925,7 @@ wheels = [
 
 [[package]]
 name = "mm-balance"
-version = "0.1.11"
+version = "0.1.13"
 source = { editable = "." }
 dependencies = [
     { name = "mm-btc" },
@@ -952,7 +952,7 @@ dev = [
 requires-dist = [
     { name = "mm-btc", specifier = "==0.1.0" },
     { name = "mm-eth", specifier = "==0.1.3" },
-    { name = "mm-solana", specifier = "==0.1.4" },
+    { name = "mm-solana", specifier = "==0.1.5" },
     { name = "typer", specifier = ">=0.12.5" },
 ]
 
@@ -1004,7 +1004,7 @@ wheels = [
 
 [[package]]
 name = "mm-solana"
-version = "0.1.4"
+version = "0.1.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "base58" },
@@ -1015,9 +1015,9 @@ dependencies = [
     { name = "solana" },
     { name = "typer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/99/9d/307c404ec6718192faebab8860fb352a667aa9903e0e58489be5f9270af1/mm_solana-0.1.4.tar.gz", hash = "sha256:fd719306c26a4f1347cc63f58dd3561b416da66fe7a615cb2a9b383b3d986268", size = 51285 }
+sdist = { url = "https://files.pythonhosted.org/packages/d9/ad/2cd6a536f8d314e2fc37d85d00b1a3a67e1731fded3b4fa82a9ca18c4eec/mm_solana-0.1.5.tar.gz", hash = "sha256:00be9fe5486484b6f31240b76ea7c7a33d364f818252bd3bb314b9b6926aed8c", size = 51391 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/db/ea/901bd6a050fc888c3264d5cf87c37d13b9ffe6373d3319639c9a5c39d5c9/mm_solana-0.1.4-py3-none-any.whl", hash = "sha256:84c966bdbc12e85430ef26237d23ef296f5df9ae915b3153ad952537780f1e83", size = 18913 },
+    { url = "https://files.pythonhosted.org/packages/29/53/75850218681cfe1a5b3bff02703193cfa89d7c41d776718df6a2c183774f/mm_solana-0.1.5-py3-none-any.whl", hash = "sha256:4d441791b8c14134651d9b27a3bee617b565b6390ad47a012efe4ad42eca8b92", size = 18927 },
 ]
 
 [[package]]

mm_balance-0.1.11/src/mm_balance/balances.py

@@ -1,169 +0,0 @@
-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.11/src/mm_balance/constants.py

@@ -1,45 +0,0 @@
-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"]
-
-
-@unique
-class Coin(str, Enum):
-    BTC = "BTC"
-    ETH = "ETH"
-    SOL = "SOL"
-    USDT = "USDT"
-    USDC = "USDC"
-
-    @classmethod
-    def usd_coins(cls) -> list[Coin]:
-        return [Coin.USDT, Coin.USDC]
-
-
-@unique
-class Network(str, Enum):
-    BTC = "btc"
-    ETH = "eth"
-    SOL = "sol"