mm-sol 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

mm_sol/account.py

@@ -1,3 +1,4 @@
+import contextlib
 import random
 
 import base58
@@ -35,8 +36,10 @@ def get_keypair(private_key: str | list[int]) -> Keypair:
     return Keypair.from_bytes(private_key_)
 
 
-def check_private_key(public_key_base58: str, private_key: str | list[int]) -> bool:
-    return str(get_keypair(private_key).pubkey()) == public_key_base58
+def check_private_key(public_key: str | Pubkey, private_key: str | list[int]) -> bool:
+    if isinstance(public_key, str):
+        public_key = Pubkey.from_string(public_key)
+    return get_keypair(private_key).pubkey() == public_key
 
 
 def get_public_key(private_key: str) -> str:
@@ -82,9 +85,8 @@ def is_empty_account(*, address: str, node: str | None = None, nodes: list[str]
     return Err(error or "unknown response", data=data)
 
 
-def is_valid_pubkey(pubkey: str) -> bool:
-    try:
+def is_address(pubkey: str) -> bool:
+    with contextlib.suppress(Exception):
         Pubkey.from_string(pubkey)
-        return True  # noqa: TRY300
-    except Exception:
-        return False
+        return True
+    return False

mm_sol/balance.py

@@ -1,18 +1,95 @@
-from mm_std import Err, Result
+import httpx
+from mm_crypto_utils import Nodes, Proxies, random_node, random_proxy
+from mm_std import Err, Ok, Result
+from solana.exceptions import SolanaRpcException
+from solana.rpc.types import TokenAccountOpts
+from solders.pubkey import Pubkey
 
 from mm_sol import rpc
-from mm_sol.types import Nodes, Proxies
-from mm_sol.utils import get_node, get_proxy
+from mm_sol.utils import get_client
 
 
-def get_balance(node: str, address: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
+def get_sol_balance(node: str, address: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
     return rpc.get_balance(node, address, timeout, proxy)
 
 
-def get_balance_with_retries(nodes: Nodes, address: str, retries: int, timeout: int = 10, proxies: Proxies = None) -> Result[int]:
+def get_sol_balance_with_retries(
+    nodes: Nodes, address: str, retries: int, timeout: int = 10, proxies: Proxies = None
+) -> Result[int]:
     res: Result[int] = Err("not started yet")
     for _ in range(retries):
-        res = get_balance(get_node(nodes), address, timeout=timeout, proxy=get_proxy(proxies))
+        res = get_sol_balance(random_node(nodes), address, timeout=timeout, proxy=random_proxy(proxies))
+        if res.is_ok():
+            return res
+    return res
+
+
+def get_token_balance(
+    node: str,
+    owner_address: str,
+    token_mint_address: str,
+    token_account: str | None = None,
+    timeout: float = 10,
+    proxy: str | None = None,
+    no_token_accounts_return_zero: bool = True,
+) -> Result[int]:
+    data: list[object] = []
+    try:
+        client = get_client(node, proxy=proxy, timeout=timeout)
+        if token_account:
+            res_balance = client.get_token_account_balance(Pubkey.from_string(token_account))
+            data.append(res_balance)
+            return Ok(int(res_balance.value.amount))
+
+        res_accounts = client.get_token_accounts_by_owner(
+            Pubkey.from_string(owner_address),
+            TokenAccountOpts(mint=Pubkey.from_string(token_mint_address)),
+        )
+        data.append(res_accounts)
+
+        if no_token_accounts_return_zero and not res_accounts.value:
+            return Ok(0)
+        if not res_accounts.value:
+            return Err("no_token_accounts")
+
+        token_accounts = [a.pubkey for a in res_accounts.value]
+        balances = []
+        for token_account_ in token_accounts:
+            res = client.get_token_account_balance(token_account_)
+            data.append(res)
+            if res.value:  # type:ignore[truthy-bool]
+                balances.append(int(res.value.amount))
+
+        return Ok(sum(balances))
+    except httpx.HTTPStatusError as e:
+        return Err(f"http error: {e}", data=data)
+    except SolanaRpcException as e:
+        return Err(e.error_msg, data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def get_token_balance_with_retries(
+    nodes: Nodes,
+    owner_address: str,
+    token_mint_address: str,
+    retries: int,
+    token_account: str | None = None,
+    timeout: float = 10,
+    proxies: Proxies = None,
+    no_token_accounts_return_zero: bool = True,
+) -> Result[int]:
+    res: Result[int] = Err("not started yet")
+    for _ in range(retries):
+        res = get_token_balance(
+            random_node(nodes),
+            owner_address,
+            token_mint_address,
+            token_account,
+            timeout=timeout,
+            proxy=random_proxy(proxies),
+            no_token_accounts_return_zero=no_token_accounts_return_zero,
+        )
         if res.is_ok():
             return res
     return res

mm_sol/cli/calcs.py

@@ -0,0 +1,101 @@
+import random
+from decimal import Decimal
+
+import mm_crypto_utils
+from loguru import logger
+from mm_crypto_utils import Nodes, Proxies
+from mm_std import Ok, Result
+from mm_std.str import split_on_plus_minus_tokens
+
+from mm_sol.balance import get_sol_balance_with_retries, get_token_balance_with_retries
+from mm_sol.converters import lamports_to_sol, sol_to_lamports, to_lamports
+
+
+def calc_var_value(value: str, *, var_name: str = "var", var_value: int | None = None, decimals: int | None = None) -> int:
+    if not isinstance(value, str):
+        raise TypeError(f"value is not str: {value}")
+    try:
+        var_name = var_name.lower()
+        result = 0
+        for token in split_on_plus_minus_tokens(value.lower()):
+            operator = token[0]
+            item = token[1:]
+            if item.isdigit():
+                item_value = int(item)
+            elif item.endswith("sol"):
+                item = item.removesuffix("sol")
+                item_value = sol_to_lamports(Decimal(item))
+            elif item.endswith("t"):
+                if decimals is None:
+                    raise ValueError("t without decimals")  # noqa: TRY301
+                item = item.removesuffix("t")
+                item_value = int(Decimal(item) * 10**decimals)
+            elif item.endswith(var_name):
+                if var_value is None:
+                    raise ValueError("base value is not set")  # noqa: TRY301
+                item = item.removesuffix(var_name)
+                k = Decimal(item) if item else Decimal(1)
+                item_value = int(k * var_value)
+            elif item.startswith("random(") and item.endswith(")"):
+                item = item.lstrip("random(").rstrip(")")
+                arr = item.split(",")
+                if len(arr) != 2:
+                    raise ValueError(f"wrong value, random part: {value}")  # noqa: TRY301
+                from_value = to_lamports(arr[0], decimals=decimals)
+                to_value = to_lamports(arr[1], decimals=decimals)
+                if from_value > to_value:
+                    raise ValueError(f"wrong value, random part: {value}")  # noqa: TRY301
+                item_value = random.randint(from_value, to_value)
+            else:
+                raise ValueError(f"wrong value: {value}")  # noqa: TRY301
+
+            if operator == "+":
+                result += item_value
+            if operator == "-":
+                result -= item_value
+
+        return result  # noqa: TRY300
+    except Exception as err:
+        raise ValueError(f"wrong value: {value}, error={err}") from err
+
+
+def is_sol_value_less_min_limit(value_min_limit: str | None, value: int, log_prefix: str | None = None) -> bool:
+    if value_min_limit is None:
+        return False
+    if value < calc_var_value(value_min_limit):
+        prefix = mm_crypto_utils.get_log_prefix(log_prefix)
+        logger.info("{}value is less min limit, value={}", prefix, lamports_to_sol(value))
+        return True
+    return False
+
+
+def calc_sol_value(*, nodes: Nodes, value_str: str, address: str, proxies: Proxies, fee: int = 5000) -> Result[int]:
+    balance_value = None
+    if "balance" in value_str.lower():
+        res = get_sol_balance_with_retries(nodes, address, proxies=proxies, retries=5)
+        if res.is_err():
+            return res
+        balance_value = res.ok
+    value = calc_var_value(value_str, var_name="balance", var_value=balance_value)
+    if "balance" in value_str.lower():
+        value = value - fee
+    return Ok(value)
+
+
+def calc_token_value(
+    *, nodes: Nodes, value_str: str, wallet_address: str, token_mint_address: str, token_decimals: int, proxies: Proxies
+) -> Result[int]:
+    balance_value = None
+    if "balance" in value_str.lower():
+        res = get_token_balance_with_retries(
+            nodes=nodes,
+            owner_address=wallet_address,
+            token_mint_address=token_mint_address,
+            proxies=proxies,
+            retries=5,
+        )
+        if res.is_err():
+            return res
+        balance_value = res.ok
+    value = calc_var_value(value_str, var_name="balance", var_value=balance_value, decimals=token_decimals)
+    return Ok(value)

mm_sol/cli/cli.py

@@ -4,7 +4,8 @@ from typing import Annotated
 import typer
 from mm_std import print_plain
 
-from .cmd import balance_cmd, balances_cmd, example_cmd, node_cmd, transfer_sol_cmd
+from . import cli_utils
+from .cmd import balance_cmd, balances_cmd, example_cmd, node_cmd, transfer_sol_cmd, transfer_token_cmd
 from .cmd.wallet import keypair_cmd, new_cmd
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
@@ -16,9 +17,7 @@ app.add_typer(wallet_app, name="w", hidden=True)
 
 def version_callback(value: bool) -> None:
     if value:
-        import importlib.metadata
-
-        print_plain(f"mm-sol: {importlib.metadata.version('mm-sol')}")
+        print_plain(f"mm-sol: {cli_utils.get_version()}")
         raise typer.Exit
 
 
@@ -55,11 +54,42 @@ def balances_command(
     balances_cmd.run(config_path, print_config)
 
 
-@app.command(name="transfer-sol", help="Transfer SOL")
+@app.command(name="transfer-sol", help="Transfer SOL from one or many accounts")
 def transfer_sol_command(
-    config_path: str, print_config: Annotated[bool, typer.Option("--config", "-c", help="Print config and exit")] = False
+    config_path: str,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances and exit"),
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    emulate: bool = typer.Option(False, "--emulate", "-e", help="Emulate transaction posting"),
+    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_sol_cmd.run(
+        config_path,
+        print_balances=print_balances,
+        print_config=print_config,
+        debug=debug,
+        no_confirmation=no_confirmation,
+        emulate=emulate,
+    )
+
+
+@app.command(name="transfer-token", help="Transfer token from one or many accounts")
+def transfer_token_command(
+    config_path: str,
+    print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances and exit"),
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    emulate: bool = typer.Option(False, "--emulate", "-e", help="Emulate transaction posting"),
+    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_sol_cmd.run(config_path, print_config)
+    transfer_token_cmd.run(
+        config_path,
+        print_balances=print_balances,
+        print_config=print_config,
+        debug=debug,
+        no_confirmation=no_confirmation,
+        emulate=emulate,
+    )
 
 
 @app.command(name="node", help="Check RPC urls")

mm_sol/cli/cli_utils.py

@@ -1,13 +1,15 @@
-import sys
+import importlib.metadata
 
-import pydash
-from mm_std import BaseConfig, fatal, hr, print_json
+from mm_crypto_utils import Proxies
+from rich.live import Live
+from rich.table import Table
 
+from mm_sol.balance import get_sol_balance_with_retries
+from mm_sol.converters import lamports_to_sol
 
-def print_config_and_exit(exit_: bool, config: BaseConfig, exclude: set[str] | None = None) -> None:
-    if exit_:
-        print_json(config.model_dump(exclude=exclude))
-        sys.exit(0)
+
+def get_version() -> str:
+    return importlib.metadata.version("mm-sol")
 
 
 def public_rpc_url(url: str | None) -> str:
@@ -25,12 +27,22 @@ def public_rpc_url(url: str | None) -> str:
     return url
 
 
-def load_proxies_from_url(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 from the url: {err}")
+def print_balances(
+    rpc_nodes: list[str],
+    addresses: list[str],
+    *,
+    proxies: Proxies = None,
+    round_ndigits: int = 5,
+) -> None:
+    table = Table(title="balances")
+    table.add_column("n")
+    table.add_column("address")
+    table.add_column("balance, sol")
+    with Live(table, refresh_per_second=0.5):
+        for count, address in enumerate(addresses):
+            balance = get_sol_balance_with_retries(rpc_nodes, address, proxies=proxies, retries=5).map_or_else(
+                lambda err: err,
+                lambda ok: str(lamports_to_sol(ok, round_ndigits)),
+            )
+            row: list[str] = [str(count), address, balance]
+            table.add_row(*row)

mm_sol/cli/cmd/balance_cmd.py

@@ -1,8 +1,10 @@
 from decimal import Decimal
 
+import mm_crypto_utils
 from mm_std import Ok, print_json
 from pydantic import BaseModel, Field
 
+import mm_sol.balance
 from mm_sol import balance, token
 from mm_sol.cli import cli_utils
 
@@ -40,10 +42,10 @@ def run(
     result = BalanceResult()
 
     rpc_url = cli_utils.public_rpc_url(rpc_url)
-    proxies = cli_utils.load_proxies_from_url(proxies_url) if proxies_url else None
+    proxies = mm_crypto_utils.fetch_proxies_or_fatal(proxies_url) if proxies_url else None
 
     # sol balance
-    sol_balance_res = balance.get_balance_with_retries(rpc_url, wallet_address, retries=3, proxies=proxies)
+    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
     else:
@@ -51,7 +53,7 @@ def run(
 
     # token balance
     if token_address:
-        token_balance_res = token.get_balance_with_retries(
+        token_balance_res = mm_sol.balance.get_token_balance_with_retries(
             nodes=rpc_url,
             owner_address=wallet_address,
             token_mint_address=token_address,

mm_sol/cli/cmd/balances_cmd.py

@@ -1,62 +1,72 @@
+import os
 import random
 from decimal import Decimal
-from typing import Any
+from typing import Annotated, Any, Self
 
-from mm_std import BaseConfig, print_console, str_to_list
-from pydantic import StrictStr, field_validator
+import mm_crypto_utils
+from mm_crypto_utils import ConfigValidators
+from mm_std import BaseConfig, print_json
+from pydantic import BeforeValidator, Field, model_validator
 
-from mm_sol import balance, utils
-from mm_sol.cli import cli_utils
-from mm_sol.token import get_balance_with_retries
+import mm_sol.converters
+from mm_sol import balance
+from mm_sol.account import is_address
+from mm_sol.balance import get_token_balance_with_retries
 
 
 class Config(BaseConfig):
-    accounts: list[StrictStr]
-    nodes: list[StrictStr]
-    tokens: list[StrictStr] | None = None
-
-    @field_validator("accounts", "nodes", "tokens", mode="before")
-    def to_list_validator(cls, v: list[str] | str | None) -> list[str]:
-        return str_to_list(v)
+    accounts: Annotated[list[str], BeforeValidator(ConfigValidators.addresses(unique=True, is_address=is_address))]
+    nodes: Annotated[list[str], BeforeValidator(ConfigValidators.nodes())]
+    tokens: Annotated[list[str], BeforeValidator(ConfigValidators.addresses(unique=True, is_address=is_address))]
+    proxies_url: str | None = None
+    proxies: list[str] = Field(default_factory=list)
 
     @property
     def random_node(self) -> str:
         return random.choice(self.nodes)
 
+    @model_validator(mode="after")
+    def final_validator(self) -> Self:
+        # fetch proxies from proxies_url
+        proxies_url = self.proxies_url or os.getenv("MM_SOL_PROXIES_URL", "")
+        if proxies_url:
+            self.proxies += mm_crypto_utils.fetch_proxies_or_fatal(proxies_url)
+
+        return self
+
 
 def run(config_path: str, print_config: bool) -> None:
     config = Config.read_config_or_exit(config_path)
-    cli_utils.print_config_and_exit(print_config, config)
+    if print_config:
+        config.print_and_exit()
 
-    # config = parse_config(ctx, config_path, Config)
-    # print_config_and_exit(ctx, config)
-    result: dict[str, Any] = {"sol": _get_sol_balances(config.accounts, config.nodes)}
+    result: dict[str, Any] = {"sol": _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 in config.tokens:
-            result[token] = _get_token_balances(token, config.accounts, config.nodes)
+            result[token] = _get_token_balances(token, config.accounts, config)
             result[token + "_sum"] = sum([v for v in result[token].values() if v is not None])
 
-    print_console(result, print_json=True)
+    print_json(result)
 
 
-def _get_token_balances(token: str, accounts: list[str], nodes: list[str]) -> dict[str, int | None]:
+def _get_token_balances(token: str, accounts: list[str], config: Config) -> dict[str, int | None]:
     result = {}
     for account in accounts:
-        # result[account] = _get_token_balance(token, account, nodes)
-        result[account] = get_balance_with_retries(
-            nodes=nodes,
+        result[account] = get_token_balance_with_retries(
+            nodes=config.nodes,
             owner_address=account,
             token_mint_address=token,
             retries=3,
+            proxies=config.proxies,
         ).ok_or_none()
     return result
 
 
-def _get_sol_balances(accounts: list[str], nodes: list[str]) -> dict[str, Decimal | None]:
+def _get_sol_balances(accounts: list[str], config: Config) -> dict[str, Decimal | None]:
     result = {}
     for account in accounts:
-        res = balance.get_balance_with_retries(nodes=nodes, address=account, retries=3)
-        result[account] = utils.lamports_to_sol(res.unwrap(), ndigits=2) if res.is_ok() else None
+        res = balance.get_sol_balance_with_retries(nodes=config.nodes, address=account, retries=3, proxies=config.proxies)
+        result[account] = mm_sol.converters.lamports_to_sol(res.unwrap(), ndigits=2) if res.is_ok() else None
     return result

mm_sol/cli/cmd/node_cmd.py

@@ -1,4 +1,4 @@
-from mm_std import print_console
+from mm_std import print_json
 
 from mm_sol import rpc
 
@@ -6,4 +6,4 @@ from mm_sol import rpc
 def run(urls: list[str], proxy: str | None) -> None:
     for url in urls:
         res = rpc.get_block_height(url, proxy=proxy, timeout=10)
-        print_console(url, res.ok_or_err())
+        print_json({url: res.ok_or_err()})