mm-sol 0.5.9__tar.gz → 0.6.0__tar.gz

{mm_sol-0.5.9 → mm_sol-0.6.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.5.9
+Version: 0.6.0
 Requires-Python: >=3.12
 Requires-Dist: base58~=2.1.1
 Requires-Dist: jinja2>=3.1.6
-Requires-Dist: mm-crypto-utils>=0.2.15
+Requires-Dist: mm-crypto-utils>=0.3.3
+Requires-Dist: mm-std>=0.4.5
 Requires-Dist: mnemonic==0.21
 Requires-Dist: socksio>=1.0.0
 Requires-Dist: solana~=0.36.6

{mm_sol-0.5.9 → mm_sol-0.6.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "mm-sol"
-version = "0.5.9"
+version = "0.6.0"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
-    "mm-crypto-utils>=0.2.15",
+    "mm-crypto-utils>=0.3.3",
     "solana~=0.36.6",
     "solders~=0.26.0",
     "base58~=2.1.1",
@@ -12,6 +12,7 @@ dependencies = [
     "typer>=0.15.2",
     "jinja2>=3.1.6",
     "socksio>=1.0.0",
+    "mm-std>=0.4.5",
 ]
 [project.scripts]
 mm-sol = "mm_sol.cli.cli:app"
@@ -24,10 +25,11 @@ build-backend = "hatchling.build"
 dev-dependencies = [
     "pytest~=8.3.5",
     "pytest-xdist~=3.6.1",
-    "ruff~=0.11.2",
+    "ruff~=0.11.6",
     "pip-audit~=2.9.0",
     "bandit~=1.8.3",
     "mypy~=1.15.0",
+    "pytest-asyncio~=0.26.0",
 ]
 
 [tool.mypy]
@@ -78,3 +80,6 @@ indent-style = "space"
 [tool.bandit]
 exclude_dirs = ["tests"]
 skips = ["B311"]
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"

{mm_sol-0.5.9 → mm_sol-0.6.0}/src/mm_sol/account.py

@@ -1,16 +1,11 @@
 import contextlib
-import random
 from dataclasses import dataclass
 
 import base58
-import pydash
-from mm_std import Err, Ok, Result
 from mnemonic import Mnemonic
 from pydantic import BaseModel
-from solana.rpc.api import Client
 from solders.keypair import Keypair
 from solders.pubkey import Pubkey
-from solders.rpc.responses import GetAccountInfoResp
 
 PHANTOM_DERIVATION_PATH = "m/44'/501'/{i}'/0'"
 WORD_STRENGTH = {12: 128, 15: 160, 18: 192, 21: 224, 24: 256}
@@ -105,27 +100,6 @@ def get_private_key_arr_str(private_key: str) -> str:
     return f"[{','.join(str(x) for x in get_private_key_arr(private_key))}]"
 
 
-def is_empty_account(*, address: str, node: str | None = None, nodes: list[str] | None = None, attempts: int = 3) -> Result[bool]:
-    if not node and not nodes:
-        raise ValueError("node or nodes must be set")
-    error = None
-    data = None
-    for _ in range(attempts):
-        try:
-            client = Client(node or random.choice(nodes))  # type: ignore[arg-type]
-            res: GetAccountInfoResp = client.get_account_info(Pubkey.from_string(address))
-            data = res
-            slot = pydash.get(res, "result.context.slot")
-            value = pydash.get(res, "result.value")
-            if slot and value is None:
-                return Ok(True, data=data)
-            if slot and value:
-                return Ok(False, data=data)
-        except Exception as e:
-            error = str(e)
-    return Err(error or "unknown response", data=data)
-
-
 def is_address(pubkey: str) -> bool:
     with contextlib.suppress(Exception):
         Pubkey.from_string(pubkey)

{mm_sol-0.5.9 → mm_sol-0.6.0}/src/mm_sol/cli/calcs.py

@@ -1,8 +1,8 @@
 import mm_crypto_utils
 from mm_crypto_utils import Nodes, Proxies, VarInt
-from mm_std import Err, Ok, Result
+from mm_std import Result
 
-from mm_sol.balance import get_sol_balance_with_retries, get_token_balance_with_retries
+from mm_sol import rpc, spl_token
 from mm_sol.constants import SUFFIX_DECIMALS
 
 
@@ -14,36 +14,32 @@ def calc_token_expression(expression: str, token_decimals: int, var: VarInt | No
     return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals={"t": token_decimals})
 
 
-def calc_sol_value_for_address(*, nodes: Nodes, value_expression: str, address: str, proxies: Proxies, fee: int) -> Result[int]:
+async def calc_sol_value_for_address(
+    *, nodes: Nodes, value_expression: str, address: str, proxies: Proxies, fee: int
+) -> Result[int]:
     value_expression = value_expression.lower()
     var = None
     if "balance" in value_expression:
-        res = get_sol_balance_with_retries(nodes, address, proxies=proxies, retries=5)
-        if isinstance(res, Err):
+        res = await rpc.get_balance_with_retries(5, nodes, proxies, address=address)
+        if res.is_error():
             return res
-        var = VarInt("balance", res.ok)
+        var = VarInt("balance", res.unwrap())
 
     value = calc_sol_expression(value_expression, var)
     if "balance" in value_expression:
         value = value - fee
-    return Ok(value)
+    return Result.success(value)
 
 
-def calc_token_value_for_address(
-    *, nodes: Nodes, value_expression: str, wallet_address: str, token_mint_address: str, token_decimals: int, proxies: Proxies
+async def calc_token_value_for_address(
+    *, nodes: Nodes, value_expression: str, owner: str, token: str, token_decimals: int, proxies: Proxies
 ) -> Result[int]:
     var = None
     value_expression = value_expression.lower()
     if "balance" in value_expression:
-        res = get_token_balance_with_retries(
-            nodes=nodes,
-            owner_address=wallet_address,
-            token_mint_address=token_mint_address,
-            proxies=proxies,
-            retries=5,
-        )
-        if isinstance(res, Err):
+        res = await spl_token.get_balance_with_retries(5, nodes, proxies, owner=owner, token=token)
+        if res.is_error():
             return res
-        var = VarInt("balance", res.ok)
+        var = VarInt("balance", res.unwrap())
     value = calc_token_expression(value_expression, token_decimals, var)
-    return Ok(value)
+    return Result.success(value)

{mm_sol-0.5.9 → mm_sol-0.6.0}/src/mm_sol/cli/cli.py

@@ -1,3 +1,4 @@
+import asyncio
 from enum import Enum
 from pathlib import Path
 from typing import Annotated
@@ -50,14 +51,14 @@ def balance_command(
     proxies_url: Annotated[str, typer.Option("--proxies-url", envvar="MM_SOL_PROXIES_URL")] = "",  # nosec
     lamport: bool = typer.Option(False, "--lamport", "-l", help="Print balances in lamports"),
 ) -> None:
-    balance_cmd.run(rpc_url, wallet_address, token_address, lamport, proxies_url)
+    asyncio.run(balance_cmd.run(rpc_url, wallet_address, token_address, lamport, proxies_url))
 
 
 @app.command(name="balances", help="Displays SOL and token balances for multiple accounts")
 def balances_command(
     config_path: Path, print_config: Annotated[bool, typer.Option("--config", "-c", help="Print config and exit")] = False
 ) -> None:
-    balances_cmd.run(config_path, print_config)
+    asyncio.run(balances_cmd.run(config_path, print_config))
 
 
 @app.command(name="transfer", help="Transfers SOL or SPL tokens, supporting multiple routes, delays, and expression-based values")
@@ -71,16 +72,18 @@ def transfer_command(
     no_confirmation: bool = typer.Option(False, "--no-confirmation", "-nc", help="Do not wait for confirmation"),
     debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
 ) -> None:
-    transfer_cmd.run(
-        TransferCmdParams(
-            config_path=config_path,
-            print_balances=print_balances,
-            print_transfers=print_transfers,
-            debug=debug,
-            no_confirmation=no_confirmation,
-            emulate=emulate,
-            print_config_and_exit=print_config or config_verbose,
-            print_config_verbose=config_verbose,
+    asyncio.run(
+        transfer_cmd.run(
+            TransferCmdParams(
+                config_path=config_path,
+                print_balances=print_balances,
+                print_transfers=print_transfers,
+                debug=debug,
+                no_confirmation=no_confirmation,
+                emulate=emulate,
+                print_config_and_exit=print_config or config_verbose,
+                print_config_verbose=config_verbose,
+            )
         )
     )
 
@@ -90,7 +93,7 @@ def node_command(
     urls: Annotated[list[str], typer.Argument()],
     proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
 ) -> None:
-    node_cmd.run(urls, proxy)
+    asyncio.run(node_cmd.run(urls, proxy))
 
 
 @wallet_app.command(name="mnemonic", help="Derive accounts from a mnemonic")

{mm_sol-0.5.9 → mm_sol-0.6.0}/src/mm_sol/cli/cmd/balance_cmd.py

@@ -1,11 +1,10 @@
 from decimal import Decimal
 
 import mm_crypto_utils
-from mm_std import Ok, print_json
+from mm_std import print_json
 from pydantic import BaseModel, Field
 
-import mm_sol.balance
-from mm_sol import balance, token
+from mm_sol import rpc, spl_token
 from mm_sol.cli import cli_utils
 
 
@@ -32,7 +31,7 @@ class BalanceResult(BaseModel):
         )
 
 
-def run(
+async def run(
     rpc_url: str,
     wallet_address: str,
     token_address: str | None,
@@ -42,34 +41,32 @@ def run(
     result = BalanceResult()
 
     rpc_url = cli_utils.public_rpc_url(rpc_url)
-    proxies = mm_crypto_utils.fetch_proxies_or_fatal(proxies_url) if proxies_url else None
+
+    proxies = await mm_crypto_utils.fetch_proxies_or_fatal(proxies_url) if proxies_url else None
 
     # sol balance
-    sol_balance_res = balance.get_sol_balance_with_retries(rpc_url, wallet_address, retries=3, proxies=proxies)
-    if isinstance(sol_balance_res, Ok):
-        result.sol_balance = sol_balance_res.ok
+    sol_balance_res = await rpc.get_balance_with_retries(3, rpc_url, proxies, address=wallet_address)
+    if sol_balance_res.is_ok():
+        result.sol_balance = sol_balance_res.unwrap()
     else:
-        result.errors.append("sol_balance: " + sol_balance_res.err)
+        result.errors.append("sol_balance: " + sol_balance_res.unwrap_error())
 
     # token balance
     if token_address:
-        token_balance_res = mm_sol.balance.get_token_balance_with_retries(
-            nodes=rpc_url,
-            owner_address=wallet_address,
-            token_mint_address=token_address,
-            retries=3,
-            proxies=proxies,
+        token_balance_res = await spl_token.get_balance_with_retries(
+            3, rpc_url, proxies, owner=wallet_address, token=token_address
         )
-        if isinstance(token_balance_res, Ok):
-            result.token_balance = token_balance_res.ok
+
+        if token_balance_res.is_ok():
+            result.token_balance = token_balance_res.unwrap()
         else:
-            result.errors.append("token_balance: " + token_balance_res.err)
+            result.errors.append("token_balance: " + token_balance_res.unwrap_error())
 
-        decimals_res = token.get_decimals_with_retries(rpc_url, token_address, retries=3, proxies=proxies)
-        if isinstance(decimals_res, Ok):
-            result.token_decimals = decimals_res.ok
+        decimals_res = await spl_token.get_decimals_with_retries(3, rpc_url, proxies, token=token_address)
+        if decimals_res.is_ok():
+            result.token_decimals = decimals_res.unwrap()
         else:
-            result.errors.append("token_decimals: " + decimals_res.err)
+            result.errors.append("token_decimals: " + decimals_res.unwrap_error())
 
     if lamport:
         print_json(result)

mm_sol-0.6.0/src/mm_sol/cli/cmd/balances_cmd.py

@@ -0,0 +1,70 @@
+import random
+from decimal import Decimal
+from pathlib import Path
+from typing import Annotated, Any
+
+from mm_crypto_utils import ConfigValidators
+from mm_std import BaseConfig, fatal, print_json
+from pydantic import BeforeValidator, Field
+
+from mm_sol import converters, rpc, spl_token
+from mm_sol.cli.validators import Validators
+
+
+class Config(BaseConfig):
+    accounts: Annotated[list[str], BeforeValidator(Validators.sol_addresses(unique=True))]
+    tokens: Annotated[list[str], BeforeValidator(Validators.sol_addresses(unique=True))]
+    nodes: Annotated[list[str], BeforeValidator(ConfigValidators.nodes())]
+    proxies: Annotated[list[str], Field(default_factory=list), BeforeValidator(Validators.proxies())]
+
+    @property
+    def random_node(self) -> str:
+        return random.choice(self.nodes)
+
+
+async def run(config_path: Path, print_config: bool) -> None:
+    config = Config.read_toml_config_or_exit(config_path)
+    if print_config:
+        config.print_and_exit()
+
+    result: dict[str, Any] = {"sol": await _get_sol_balances(config.accounts, config)}
+    result["sol_sum"] = sum([v for v in result["sol"].values() if v is not None])
+
+    if config.tokens:
+        for token_address in config.tokens:
+            res = await spl_token.get_decimals_with_retries(3, config.nodes, config.proxies, token=token_address)
+            if res.is_error():
+                fatal(f"Failed to get decimals for token {token_address}: {res.unwrap_error()}")
+
+            token_decimals = res.unwrap()
+            result[token_address] = await _get_token_balances(token_address, token_decimals, config.accounts, config)
+            result[token_address + "_decimals"] = token_decimals
+            result[token_address + "_sum"] = sum([v for v in result[token_address].values() if v is not None])
+
+    print_json(result)
+
+
+async def _get_token_balances(
+    token_address: str, token_decimals: int, accounts: list[str], config: Config
+) -> dict[str, Decimal | None]:
+    result: dict[str, Decimal | None] = {}
+    for account in accounts:
+        result[account] = (
+            (await spl_token.get_balance_with_retries(3, config.nodes, config.proxies, owner=account, token=token_address))
+            .map(lambda v: converters.to_token(v, token_decimals))
+            .ok
+        )
+
+    return result
+
+
+async def _get_sol_balances(accounts: list[str], config: Config) -> dict[str, Decimal | None]:
+    result = {}
+    for account in accounts:
+        result[account] = (
+            (await rpc.get_balance_with_retries(3, config.nodes, config.proxies, address=account))
+            .map(lambda v: converters.lamports_to_sol(v))
+            .ok
+        )
+
+    return result

{mm_sol-0.5.9 → mm_sol-0.6.0}/src/mm_sol/cli/cmd/node_cmd.py

@@ -4,8 +4,8 @@ from mm_sol import rpc
 from mm_sol.cli import cli_utils
 
 
-def run(urls: list[str], proxy: str | None) -> None:
+async def run(urls: list[str], proxy: str | None) -> None:
     result = {}
     for url in [cli_utils.public_rpc_url(u) for u in urls]:
-        result[url] = rpc.get_block_height(url, proxy=proxy, timeout=10).ok_or_err()
+        result[url] = (await rpc.get_block_height(url, proxy=proxy, timeout=10)).ok_or_error()
     print_json(data=result)

{mm_sol-0.5.9 → mm_sol-0.6.0}/src/mm_sol/cli/cmd/transfer_cmd.py

@@ -1,24 +1,23 @@
+import asyncio
 import sys
-import time
 from pathlib import Path
-from typing import Annotated, Self
+from typing import Annotated
 
 import mm_crypto_utils
 from loguru import logger
 from mm_crypto_utils import AddressToPrivate, Transfer
-from mm_std import BaseConfig, Err, fatal, utc_now
+from mm_std import BaseConfig, fatal, utc_now
 from pydantic import AfterValidator, BeforeValidator, Field, model_validator
 from rich.console import Console
 from rich.live import Live
 from rich.table import Table
 from solders.signature import Signature
 
-from mm_sol.balance import get_sol_balance_with_retries, get_token_balance_with_retries
+from mm_sol import rpc, spl_token
 from mm_sol.cli import calcs, cli_utils
 from mm_sol.cli.cli_utils import BaseConfigParams
 from mm_sol.cli.validators import Validators
 from mm_sol.converters import lamports_to_sol, to_token
-from mm_sol.token import get_decimals_with_retries
 from mm_sol.transfer import transfer_sol_with_retries, transfer_token_with_retries
 
 
@@ -40,8 +39,8 @@ class Config(BaseConfig):
     def from_addresses(self) -> list[str]:
         return [r.from_address for r in self.transfers]
 
-    @model_validator(mode="after")
-    def final_validator(self) -> Self:
+    @model_validator(mode="after")  # type: ignore[misc]
+    async def final_validator(self) -> "Config":
         if not self.private_keys.contains_all_addresses(self.from_addresses):
             raise ValueError("private keys are not set for all addresses")
 
@@ -64,10 +63,10 @@ class Config(BaseConfig):
                 Validators.valid_sol_expression()(self.value_min_limit)
 
         if self.token:
-            res = get_decimals_with_retries(self.nodes, self.token, retries=3, proxies=self.proxies)
-            if isinstance(res, Err):
-                fatal(f"can't get decimals for token={self.token}, error={res.err}")
-            self.token_decimals = res.ok
+            res = await spl_token.get_decimals_with_retries(3, self.nodes, self.proxies, token=self.token)
+            if res.is_error():
+                fatal(f"can't get decimals for token={self.token}, error={res.unwrap_error()}")
+            self.token_decimals = res.unwrap()
 
         return self
 
@@ -81,8 +80,8 @@ class TransferCmdParams(BaseConfigParams):
     print_config_verbose: bool
 
 
-def run(cmd_params: TransferCmdParams) -> None:
-    config = Config.read_toml_config_or_exit(cmd_params.config_path)
+async def run(cmd_params: TransferCmdParams) -> None:
+    config = await Config.read_toml_config_or_exit_async(cmd_params.config_path)
 
     if cmd_params.print_config_and_exit:
         cli_utils.print_config(config, exclude={"private_keys"}, count=None if cmd_params.debug else {"proxies"})
@@ -93,47 +92,47 @@ def run(cmd_params: TransferCmdParams) -> None:
         sys.exit(0)
 
     if cmd_params.print_balances:
-        _print_balances(config)
+        await _print_balances(config)
         sys.exit(0)
 
-    _run_transfers(config, cmd_params)
+    await _run_transfers(config, cmd_params)
 
 
-def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
+async def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
     mm_crypto_utils.init_logger(cmd_params.debug, config.log_debug, config.log_info)
     logger.info(f"transfer {cmd_params.config_path}: started at {utc_now()} UTC")
     logger.debug(f"config={config.model_dump(exclude={'private_keys'}) | {'version': cli_utils.get_version()}}")
     for i, route in enumerate(config.transfers):
-        _transfer(route, config, cmd_params)
+        await _transfer(route, config, cmd_params)
         if config.delay is not None and i < len(config.transfers) - 1:
             delay_value = mm_crypto_utils.calc_decimal_value(config.delay)
             logger.info(f"delay {delay_value} seconds")
             if not cmd_params.emulate:
-                time.sleep(float(delay_value))
+                await asyncio.sleep(float(delay_value))
     logger.info(f"transfer {cmd_params.config_path}: finished at {utc_now()} UTC")
 
 
-def _calc_value(transfer: Transfer, config: Config, transfer_sol_fee: int) -> int | None:
+async def _calc_value(transfer: Transfer, config: Config, transfer_sol_fee: int) -> int | None:
     if config.token:
-        value_res = calcs.calc_token_value_for_address(
+        value_res = await calcs.calc_token_value_for_address(
             nodes=config.nodes,
             value_expression=transfer.value,
-            wallet_address=transfer.from_address,
+            owner=transfer.from_address,
             proxies=config.proxies,
-            token_mint_address=config.token,
+            token=config.token,
             token_decimals=config.token_decimals,
         )
     else:
-        value_res = calcs.calc_sol_value_for_address(
+        value_res = await calcs.calc_sol_value_for_address(
             nodes=config.nodes,
             value_expression=transfer.value,
             address=transfer.from_address,
             proxies=config.proxies,
             fee=transfer_sol_fee,
         )
-    logger.debug(f"{transfer.log_prefix}: value={value_res.ok_or_err()}")
-    if isinstance(value_res, Err):
-        logger.info(f"{transfer.log_prefix}: calc value error, {value_res.err}")
+    logger.debug(f"{transfer.log_prefix}: value={value_res.ok_or_error()}")
+    if value_res.is_error():
+        logger.info(f"{transfer.log_prefix}: calc value error, {value_res.unwrap_error()}")
 
     return value_res.ok
 
@@ -156,41 +155,41 @@ def _value_with_suffix(value: int, config: Config) -> str:
     return f"{lamports_to_sol(value, config.round_ndigits)}sol"
 
 
-def _send_tx(transfer: Transfer, value: int, config: Config) -> Signature | None:
+async def _send_tx(transfer: Transfer, value: int, config: Config) -> Signature | None:
     logger.debug(f"{transfer.log_prefix}: value={_value_with_suffix(value, config)}")
     if config.token:
-        res = transfer_token_with_retries(
-            nodes=config.nodes,
+        res = await transfer_token_with_retries(
+            3,
+            config.nodes,
+            config.proxies,
             token_mint_address=config.token,
             from_address=transfer.from_address,
             private_key=config.private_keys[transfer.from_address],
             to_address=transfer.to_address,
             amount=value,
             decimals=config.token_decimals,
-            proxies=config.proxies,
-            retries=3,
         )
     else:
-        res = transfer_sol_with_retries(
-            nodes=config.nodes,
+        res = await transfer_sol_with_retries(
+            3,
+            config.nodes,
+            config.proxies,
             from_address=transfer.from_address,
             private_key=config.private_keys[transfer.from_address],
             to_address=transfer.to_address,
             lamports=value,
-            proxies=config.proxies,
-            retries=3,
         )
 
-    if isinstance(res, Err):
-        logger.info(f"{transfer.log_prefix}: tx error {res.err}")
+    if res.is_error():
+        logger.info(f"{transfer.log_prefix}: tx error {res.unwrap_error()}")
         return None
     return res.ok
 
 
-def _transfer(transfer: Transfer, config: Config, cmd_params: TransferCmdParams) -> None:
+async def _transfer(transfer: Transfer, config: Config, cmd_params: TransferCmdParams) -> None:
     transfer_sol_fee = 5000
 
-    value = _calc_value(transfer, config, transfer_sol_fee)
+    value = await _calc_value(transfer, config, transfer_sol_fee)
     if value is None:
         return
 
@@ -201,7 +200,7 @@ def _transfer(transfer: Transfer, config: Config, cmd_params: TransferCmdParams)
         logger.info(f"{transfer.log_prefix}: emulate, value={_value_with_suffix(value, config)}")
         return
 
-    signature = _send_tx(transfer, value, config)
+    signature = await _send_tx(transfer, value, config)
     if signature is None:
         return
 
@@ -222,7 +221,7 @@ def _print_transfers(config: Config) -> None:
     console.print(table)
 
 
-def _print_balances(config: Config) -> None:
+async def _print_balances(config: Config) -> None:
     if config.token:
         headers = ["n", "from_address", "sol", "t", "to_address", "sol", "t"]
     else:
@@ -230,10 +229,10 @@ def _print_balances(config: Config) -> None:
     table = Table(*headers, title="balances")
     with Live(table, refresh_per_second=0.5):
         for count, route in enumerate(config.transfers):
-            from_sol_balance = _get_sol_balance_str(route.from_address, config)
-            to_sol_balance = _get_sol_balance_str(route.to_address, config)
-            from_t_balance = _get_token_balance_str(route.from_address, config) if config.token else ""
-            to_t_balance = _get_token_balance_str(route.to_address, config) if config.token else ""
+            from_sol_balance = await _get_sol_balance_str(route.from_address, config)
+            to_sol_balance = await _get_sol_balance_str(route.to_address, config)
+            from_t_balance = await _get_token_balance_str(route.from_address, config) if config.token else ""
+            to_t_balance = await _get_token_balance_str(route.to_address, config) if config.token else ""
 
             if config.token:
                 table.add_row(
@@ -255,17 +254,13 @@ def _print_balances(config: Config) -> None:
                 )
 
 
-def _get_sol_balance_str(address: str, config: Config) -> str:
-    return get_sol_balance_with_retries(config.nodes, address, proxies=config.proxies, retries=5).map_or_else(
-        lambda err: err,
-        lambda ok: str(lamports_to_sol(ok, config.round_ndigits)),
-    )
+async def _get_sol_balance_str(address: str, config: Config) -> str:
+    res = await rpc.get_balance_with_retries(5, config.nodes, config.proxies, address=address)
+    return res.map(lambda ok: str(lamports_to_sol(ok, config.round_ndigits))).ok_or_error()
 
 
-def _get_token_balance_str(address: str, config: Config) -> str:
+async def _get_token_balance_str(address: str, config: Config) -> str:
     if not config.token:
         raise ValueError("token is not set")
-    return get_token_balance_with_retries(config.nodes, address, config.token, proxies=config.proxies, retries=5).map_or_else(
-        lambda err: err,
-        lambda ok: str(to_token(ok, config.token_decimals, ndigits=config.round_ndigits)),
-    )
+    res = await spl_token.get_balance_with_retries(5, config.nodes, config.proxies, owner=address, token=config.token)
+    return res.map(lambda ok: str(to_token(ok, config.token_decimals, ndigits=config.round_ndigits))).ok_or_error()