mm-balance 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

mm_balance/balances.py

@@ -4,88 +4,166 @@ from decimal import Decimal
 
 from mm_std import ConcurrentTasks, Result
 from pydantic import BaseModel
+from rich.progress import TaskID
 
-from mm_balance import btc, eth, solana
+from mm_balance import output
 from mm_balance.config import Config
+from mm_balance.rpc import btc, eth, solana
+from mm_balance.token_decimals import TokenDecimals
 from mm_balance.types import Network
 
 
-class Balances(BaseModel):
+class Balances:
     class Balance(BaseModel):
         group_index: int
         address: str
         token_address: str | None
         balance: Result[Decimal] | None = None
 
-    config: Config
-    # 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 __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] = {}
 
-    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
+        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)
 
-        return [b for b in network_balances if b.group_index == group_index]
+        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:
-        job = ConcurrentTasks()
-        job.add_task("btc", self._process_btc)
-        job.add_task("eth", self._process_eth)
-        job.add_task("sol", self._process_sol)
-        job.execute()
+        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_btc(self) -> 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))
+    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.btc):
-            self.btc[idx].balance = job.result.get(str(idx))  # type: ignore[assignment]
+        for idx, _task in enumerate(self.tasks[network]):
+            self.tasks[network][idx].balance = job.result.get(str(idx))  # type: ignore[assignment]
 
-    def _process_eth(self) -> None:
-        job = ConcurrentTasks(max_workers=self.config.workers.eth)
-        for idx, task in enumerate(self.eth):
-            job.add_task(str(idx), eth.get_balance, args=(task.address, task.token_address, self.config))
-        job.execute()
-        for idx, _task in enumerate(self.eth):
-            self.eth[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, self.config)
+            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)
 
-    def _process_sol(self) -> 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))
-        job.execute()
-        for idx, _task in enumerate(self.sol):
-            self.sol[idx].balance = job.result.get(str(idx))  # type: ignore[assignment]
+            case _:
+                raise ValueError
 
-    @staticmethod
-    def from_config(config: Config) -> Balances:
-        tasks = Balances(config=config, btc=[], eth=[], sol=[])
-        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]
-            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
+        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/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,7 +32,8 @@ 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)
+    token_decimals = get_token_decimals(config)
+    balances = Balances(config, token_decimals)
     balances.process()
 
     output.print_prices(config, prices)

mm_balance/config/example.yml

@@ -3,6 +3,11 @@ groups:
     addresses:
       - 2ojv9BAiHUrvsm9gxDe7fJSzbNZSJcxZvf8dqmWGHG8S # binance
 
+  - coin: usdt
+    network: sol
+    addresses:
+      - 2ojv9BAiHUrvsm9gxDe7fJSzbNZSJcxZvf8dqmWGHG8S # binance
+
   - coin: btc
     comment: coldwallets
     addresses: |

mm_balance/config.py

@@ -4,10 +4,10 @@ from decimal import Decimal
 from typing import Any, Self
 
 import pydash
-from mm_std import BaseConfig, Err, PrintFormat, fatal, hr
+from mm_std import BaseConfig, PrintFormat, fatal, hr
 from pydantic import Field, field_validator, model_validator
 
-from mm_balance.types import DEFAULT_ETH_NODES, DEFAULT_SOL_NODES, EthTokenAddress, Network
+from mm_balance.types import DEFAULT_ETH_NODES, DEFAULT_SOL_NODES, EthTokenAddress, Network, SolTokenAddress
 
 
 class Config(BaseConfig):
@@ -67,14 +67,6 @@ class Config(BaseConfig):
         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 Workers(BaseConfig):
-        btc: int = 5
-        eth: int = 5
-        sol: int = 5
-
-    class TokenDecimals(BaseConfig):
-        eth: dict[str, int] = Field(default_factory=dict)
-
     groups: list[Group]
     addresses: list[AddressGroup] = Field(default_factory=list)
 
@@ -85,9 +77,7 @@ class Config(BaseConfig):
     print_format: PrintFormat = PrintFormat.TABLE
     price: bool = True
 
-    # non configs
-    workers: Workers = Workers()
-    token_decimals: TokenDecimals = TokenDecimals()
+    workers: dict[Network, int] = {network: 5 for network in Network}
 
     def btc_groups(self) -> list[Group]:
         return [g for g in self.groups if g.network == Network.BTC]
@@ -119,16 +109,6 @@ class Config(BaseConfig):
         if Network.SOL not in self.nodes:
             self.nodes[Network.SOL] = DEFAULT_SOL_NODES
 
-        # load token decimals
-        for group in self.groups:
-            if group.network == Network.ETH and group.token_address is not None:
-                from mm_balance import eth
-
-                decimals_res = eth.get_token_decimals(group.token_address, self)
-                if isinstance(decimals_res, Err):
-                    fatal(f"can't get decimals for token {group.coin} / {group.token_address}, error={decimals_res.err}")
-                self.token_decimals.eth[group.token_address] = decimals_res.ok
-
         return self
 
 
@@ -151,6 +131,12 @@ def detect_token_address(coin: str, network: str) -> str | None:
         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:

mm_balance/output.py

@@ -1,6 +1,7 @@
 from decimal import Decimal
 
 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
@@ -54,3 +55,15 @@ def print_prices(config: Config, prices: Prices) -> None:
 def print_total(config: Config, balances: Balances, prices: Prices) -> None:
     total = Total.calc(balances, prices, config)
     total.print()
+
+
+def create_progress_bar() -> Progress:
+    return Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+    )
+
+
+def create_progress_task(progress: Progress, description: str, total: int) -> TaskID:
+    return progress.add_task("[green]" + description, total=total)

mm_balance/price.py

@@ -5,6 +5,7 @@ import pydash
 from mm_std import Err, Ok, Result, fatal, hr
 from mm_std.random_ import random_str_choice
 
+from mm_balance import output
 from mm_balance.config import Config
 from mm_balance.types import EthTokenAddress, Network
 
@@ -20,17 +21,25 @@ class Prices(dict[str, Decimal]):
 
 def get_prices(config: Config) -> Prices:
     result = Prices()
-    for group in config.groups:
-        if group.coin in result:
-            continue
-
-        coingecko_id = get_coingecko_id(group)
-        res = get_asset_price(coingecko_id, config.proxies)
-        if isinstance(res, Ok):
-            result[group.coin] = res.ok
-        else:
-            fatal(res.err)
-            # raise ValueError(res.err)
+    coins_total = len(pydash.uniq([group.coin for group in config.groups]))
+
+    progress = output.create_progress_bar()
+
+    with progress:
+        task_id = output.create_progress_task(progress, "prices", total=coins_total)
+
+        for group in config.groups:
+            if group.coin in result:
+                continue
+
+            coingecko_id = get_coingecko_id(group)
+            res = get_asset_price(coingecko_id, config.proxies)
+            if isinstance(res, Ok):
+                result[group.coin] = res.ok
+                progress.update(task_id, advance=1)
+            else:
+                fatal(res.err)
+                # raise ValueError(res.err)
 
     return result
 

mm_balance/{btc.py → rpc/btc.py}

@@ -2,15 +2,19 @@ from decimal import Decimal
 
 from mm_btc.blockstream import BlockstreamClient
 from mm_std import Ok, Result
+from rich.progress import Progress, TaskID
 
 from mm_balance.config import Config
 
 
-def get_balance(address: str, config: Config) -> Result[Decimal]:
-    return (
+def get_balance(address: str, config: Config, progress: Progress | None = None, task_id: TaskID | None = None) -> Result[Decimal]:
+    res: Result[Decimal] = (
         BlockstreamClient(proxies=config.proxies, attempts=3)
         .get_confirmed_balance(address)
         .and_then(
             lambda b: Ok(round(Decimal(b / 100_000_000), config.round_ndigits)),
         )
     )
+    if task_id is not None and progress is not None:
+        progress.update(task_id, advance=1)
+    return res

mm_balance/rpc/eth.py

@@ -0,0 +1,46 @@
+from decimal import Decimal
+
+from mm_eth import erc20, rpc
+from mm_std import Ok, Result
+
+
+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=5, timeout=10).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=5,
+        timeout=10,
+    ).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=10, proxies=proxies, attempts=5)
+
+
+# def get_balance(
+#         address: str, token_address: str | None, config: Config, progress: Progress | None = None, task_id: TaskID | None = None
+# ) -> Result[Decimal]:
+#     res: Result[Decimal]
+#
+#     if token_address is not None:
+#
+#     else:
+#         res = rpc.eth_get_balance(config.nodes[Network.ETH], address, proxies=config.proxies, attempts=5, timeout=10).and_then(
+#             lambda b: Ok(round(Decimal(b / 10 ** 18), config.round_ndigits)),
+#         )
+#
+#     if task_id is not None and progress is not None:
+#         progress.update(task_id, advance=1)
+#     return res

mm_balance/rpc/solana.py

@@ -0,0 +1,22 @@
+from decimal import Decimal
+
+from mm_solana import balance, token
+from mm_std import Ok, Result
+
+
+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=5, timeout=5, 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=5, timeout=5, 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=5, timeout=5, proxies=proxies)

mm_balance/token_decimals.py

@@ -0,0 +1,37 @@
+from mm_std import Err, fatal
+
+from mm_balance.config import Config
+from mm_balance.rpc import eth, solana
+from mm_balance.types import Network
+
+
+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/total.py

@@ -15,7 +15,6 @@ from mm_balance.types import Coin
 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

mm_balance/types.py

@@ -30,3 +30,9 @@ class Network(str, Enum):
 class EthTokenAddress(str, Enum):
     USDT = "0xdac17f958d2ee523a2206206994597c13d831ec7"
     USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+
+
+@unique
+class SolTokenAddress(str, Enum):
+    USDT = "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
+    USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"

{mm_balance-0.1.8.dist-info → mm_balance-0.1.10.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: mm-balance
-Version: 0.1.8
+Version: 0.1.10
 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.10.dist-info/RECORD

@@ -0,0 +1,18 @@
+mm_balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_balance/balances.py,sha256=iERBZ_kTqj1wSlwUv5O2OteEhK2FMttD8Enx2avQHm0,7572
+mm_balance/cli.py,sha256=qKmupsRR3dGKZzA5hrKgmd4N4SoRMKTI8HAiwhSvgXI,1359
+mm_balance/config.py,sha256=n6NbsgnB-Uus4kOZJr37n7BnHc539LH8LT6BpJbqhVU,5370
+mm_balance/output.py,sha256=Sb0pccEBNOCR9fuMigO9GJcyTNw9XPRZXTg8iznJKFQ,2568
+mm_balance/price.py,sha256=KyMx1T57SczKbYmbghpGty9BrPebrZdjBW0_BaabKDk,2926
+mm_balance/token_decimals.py,sha256=UlYzLFR_w-jAsotq8CjGJc38KwklWG0Tr0JK-_wK6QQ,1293
+mm_balance/total.py,sha256=OuXfKKy18X9f7HO_RJNFh4M8VPVH0MBb3soSRsqS_RY,4696
+mm_balance/types.py,sha256=O6mjf2UYSl2XzwMU8Zsg_T2iYdSxZPg2-7UV1UORaMU,822
+mm_balance/config/example.yml,sha256=A3pGt8BVykKNajfhHziTM7RLM1KSZOm_kmhCQExQkgo,1336
+mm_balance/rpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_balance/rpc/btc.py,sha256=OozGSF8CzR13jxTYjvBqkC8d0pdKkyEHxM7e7M_WbV0,681
+mm_balance/rpc/eth.py,sha256=vWjgvP2P_ejwK_dsxS3NZCP0PJyLFDndvfVaZIePXOU,1578
+mm_balance/rpc/solana.py,sha256=NIa494HjvHYONutKV_6HGcJV5tqiRvA1099JVkrrdd8,972
+mm_balance-0.1.10.dist-info/METADATA,sha256=fDZjEFqUMNBwhqwoyG0ldd65jlV2EEqnKhZ00PynqN0,198
+mm_balance-0.1.10.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+mm_balance-0.1.10.dist-info/entry_points.txt,sha256=rSnP0ZW1a3ACNwTWM7T53CmOycKbzhG43m2_wseENng,50
+mm_balance-0.1.10.dist-info/RECORD,,

mm_balance/eth.py

@@ -1,29 +0,0 @@
-from decimal import Decimal
-
-from mm_eth import erc20, rpc
-from mm_std import Ok, Result
-
-from mm_balance.config import Config
-from mm_balance.types import Network
-
-
-def get_balance(address: str, token_address: str | None, config: Config) -> Result[Decimal]:
-    if token_address is not None:
-        return erc20.get_balance(
-            config.nodes[Network.ETH],
-            token_address,
-            address,
-            proxies=config.proxies,
-            attempts=5,
-            timeout=10,
-        ).and_then(
-            lambda b: Ok(round(Decimal(b / 10 ** config.token_decimals.eth[token_address]), config.round_ndigits)),
-        )
-    else:
-        return rpc.eth_get_balance(config.nodes[Network.ETH], address, proxies=config.proxies, attempts=5, timeout=10).and_then(
-            lambda b: Ok(round(Decimal(b / 10**18), config.round_ndigits)),
-        )
-
-
-def get_token_decimals(token_address: str, config: Config) -> Result[int]:
-    return erc20.get_decimals(config.nodes[Network.ETH], token_address, timeout=10, proxies=config.proxies, attempts=5)

mm_balance/solana.py

@@ -1,13 +0,0 @@
-from decimal import Decimal
-
-from mm_solana.balance import sol_balance
-from mm_std import Ok, Result
-
-from mm_balance.config import Config
-from mm_balance.types import Network
-
-
-def get_balance(address: str, config: Config) -> Result[Decimal]:
-    return sol_balance(address=address, nodes=config.nodes[Network.SOL], proxies=config.proxies, attempts=5, timeout=10).and_then(
-        lambda b: Ok(round(Decimal(b / 1_000_000_000), config.round_ndigits)),
-    )

mm_balance-0.1.8.dist-info/RECORD

@@ -1,16 +0,0 @@
-mm_balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_balance/balances.py,sha256=UGhJBecq-2CfNYdXE2EWjDcKkfPG30MERawOtWq5D5E,3399
-mm_balance/btc.py,sha256=h8hjcRk6BM0JwhAnB_V39wzeRO94s_hsOlzG7XpE9nk,445
-mm_balance/cli.py,sha256=VpiNJdwels7qWuklpV7kNEYm0lhsN4NJ7yENIsQLdK8,1250
-mm_balance/config.py,sha256=VGw8f9oQbu5qUJD5lcMnd6kKtXzyX5-CEqcRNd8mgVo,5914
-mm_balance/eth.py,sha256=wFpbqo4wHupTeMc9ybCPUkBBaJWxiWCBYJO3LvvU39s,1066
-mm_balance/output.py,sha256=hCLq-hynO0c_MJrKSzOoY0p8yFGDZOb5_mE_pqGaBrc,2144
-mm_balance/price.py,sha256=xKwF0bWySfnryDYxsPTd2c8C82mrm1TXxIRzRmu_0MA,2577
-mm_balance/solana.py,sha256=tK1JHGo9ioIz-jXZ9pRDbACjQh_3vhgqFx1wZKVot6M,460
-mm_balance/total.py,sha256=gdH9BzFgc-akVVrsCJ6NqN6cIS9mkEfp-TTKcn01I0U,4944
-mm_balance/types.py,sha256=8TflwL3KJ8HQW31qa8xrh-gyJT232lN1XznuNnIR6zM,662
-mm_balance/config/example.yml,sha256=6_S0hBdh7gMyO1ZPTGxmL21bBSzzmXuJHB0eWqKGueU,1225
-mm_balance-0.1.8.dist-info/METADATA,sha256=3fUpPe2SujgWG7zghwkJAkXOMDY0g4EYIP7KOChheUs,197
-mm_balance-0.1.8.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-mm_balance-0.1.8.dist-info/entry_points.txt,sha256=rSnP0ZW1a3ACNwTWM7T53CmOycKbzhG43m2_wseENng,50
-mm_balance-0.1.8.dist-info/RECORD,,