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

mm_sol/account.py

@@ -35,8 +35,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:

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,93 @@
+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 Err
+from mm_std.str import split_on_plus_minus_tokens
+
+from mm_sol.balance import get_sol_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,
+    log_prefix: str | None = None,
+) -> int | None:
+    balance_value = None
+    if "balance" in value_str.lower():
+        prefix = mm_crypto_utils.get_log_prefix(log_prefix)
+        res = get_sol_balance_with_retries(nodes, address, proxies=proxies, retries=5)
+        logger.debug(f"{prefix}balance={res.ok_or_err()}")
+        if isinstance(res, Err):
+            logger.info(f"{prefix}balance error, {res.err}")
+            return None
+        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 value

mm_sol/cli/cli.py

@@ -4,6 +4,7 @@ from typing import Annotated
 import typer
 from mm_std import print_plain
 
+from . import cli_utils
 from .cmd import balance_cmd, balances_cmd, example_cmd, node_cmd, transfer_sol_cmd
 from .cmd.wallet import keypair_cmd, new_cmd
 
@@ -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,23 @@ 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_config)
+    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="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_valid_pubkey
+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_valid_pubkey))]
+    nodes: Annotated[list[str], BeforeValidator(ConfigValidators.nodes())]
+    tokens: Annotated[list[str], BeforeValidator(ConfigValidators.addresses(unique=True, is_address=is_valid_pubkey))]
+    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()})

mm_sol/cli/cmd/transfer_sol_cmd.py

@@ -1,41 +1,194 @@
-import random
-from decimal import Decimal
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Annotated, Self
 
-from mm_std import BaseConfig, print_console, str_to_list
-from pydantic import StrictStr, field_validator
+import mm_crypto_utils
+from loguru import logger
+from mm_crypto_utils import AddressToPrivate, ConfigValidators, TxRoute
+from mm_std import BaseConfig, Err, utc_now
+from pydantic import BeforeValidator, Field, model_validator
+from solders.signature import Signature
 
-from mm_sol.cli import cli_utils
-from mm_sol.transfer import transfer_sol
+from mm_sol import transfer
+from mm_sol.account import get_public_key, is_valid_pubkey
+from mm_sol.cli import calcs, cli_utils, validators
+from mm_sol.converters import lamports_to_sol
+from mm_sol.utils import get_client
 
 
 class Config(BaseConfig):
-    from_address: StrictStr
-    private_key: StrictStr
-    recipients: list[StrictStr]
-    nodes: list[StrictStr]
-    amount: Decimal
-
-    @field_validator("recipients", "nodes", mode="before")
-    def to_list_validator(cls, v: list[str] | str | None) -> list[str]:
-        return str_to_list(v)
+    nodes: Annotated[list[str], BeforeValidator(ConfigValidators.nodes())]
+    routes: Annotated[list[TxRoute], BeforeValidator(ConfigValidators.routes(is_valid_pubkey))]
+    routes_from_file: Path | None = None
+    routes_to_file: Path | None = None
+    private_keys: Annotated[
+        AddressToPrivate, Field(default_factory=AddressToPrivate), BeforeValidator(ConfigValidators.private_keys(get_public_key))
+    ]
+    private_keys_file: Path | None = None
+    proxies_url: str | None = None
+    proxies: list[str] = Field(default_factory=list)
+    value: str
+    value_min_limit: str | None = None
+    delay: str | None = None  # in seconds
+    round_ndigits: int = 5
+    log_debug: Annotated[Path | None, BeforeValidator(ConfigValidators.log_file())] = None
+    log_info: Annotated[Path | None, BeforeValidator(ConfigValidators.log_file())] = None
 
     @property
-    def random_node(self) -> str:
-        return random.choice(self.nodes)
+    def from_addresses(self) -> list[str]:
+        return [r.from_address for r in self.routes]
+
+    @model_validator(mode="after")
+    def final_validator(self) -> Self:
+        # routes_files
+        if self.routes_from_file and self.routes_to_file:
+            self.routes += TxRoute.from_files(self.routes_from_file, self.routes_to_file, is_valid_pubkey)
+        if not self.routes:
+            raise ValueError("routes is empty")
+
+        # load private keys from file
+        if self.private_keys_file:
+            self.private_keys.update(AddressToPrivate.from_file(self.private_keys_file, get_public_key))
+
+        # check all private keys exist
+        if not self.private_keys.contains_all_addresses(self.from_addresses):
+            raise ValueError("private keys are not set for all addresses")
+
+        # fetch proxies from proxies_url
+        proxies_url = self.proxies_url or os.getenv("MM_PROXIES_URL", "")
+        if proxies_url:
+            self.proxies += mm_crypto_utils.fetch_proxies_or_fatal(proxies_url)
+
+        # value
+        if not validators.is_valid_var_lamports(self.value, "balance"):
+            raise ValueError(f"wrong value: {self.value}")
+
+        # value_min_limit
+        if not validators.is_valid_var_lamports(self.value_min_limit):
+            raise ValueError(f"wrong value_min_limit: {self.value_min_limit}")
 
+        # delay
+        if not validators.is_valid_var_lamports(self.delay):
+            raise ValueError(f"wrong delay: {self.delay}")
 
-def run(config_path: str, print_config: bool) -> None:
+        return self
+
+
+def run(
+    config_path: str,
+    *,
+    print_balances: bool,
+    print_config: bool,
+    debug: bool,
+    no_confirmation: bool,
+    emulate: bool,
+) -> None:
     config = Config.read_config_or_exit(config_path)
-    cli_utils.print_config_and_exit(print_config, config)
-
-    result = {}
-    for recipient in config.recipients:
-        res = transfer_sol(
-            from_address=config.from_address,
-            private_key_base58=config.private_key,
-            recipient_address=recipient,
-            amount_sol=config.amount,
-            nodes=config.nodes,
+
+    if print_config:
+        config.print_and_exit({"private_keys", "proxies"})
+
+    mm_crypto_utils.init_logger(debug, config.log_debug, config.log_info)
+
+    if print_balances:
+        cli_utils.print_balances(config.nodes, config.from_addresses, round_ndigits=config.round_ndigits, proxies=config.proxies)
+        sys.exit(0)
+
+    _run_transfers(config, no_confirmation=no_confirmation, emulate=emulate)
+
+
+def _run_transfers(config: Config, *, no_confirmation: bool, emulate: bool) -> None:
+    logger.info(f"started at {utc_now()} UTC")
+    logger.debug(
+        f"config={config.model_dump(exclude={'private_keys', 'addresses_map', 'proxies'}) | {'version': cli_utils.get_version()}}"
+    )
+    for i, route in enumerate(config.routes):
+        _transfer(
+            from_address=route.from_address,
+            to_address=route.to_address,
+            config=config,
+            no_confirmation=no_confirmation,
+            emulate=emulate,
         )
-        result[recipient] = res.ok_or_err()
-    print_console(result, print_json=True)
+        if not emulate and config.delay is not None and i < len(config.routes) - 1:
+            delay_value = mm_crypto_utils.calc_decimal_value(config.delay)
+            logger.debug(f"delay {delay_value} seconds")
+            time.sleep(float(delay_value))
+    logger.info(f"finished at {utc_now()} UTC")
+
+
+def _transfer(*, from_address: str, to_address: str, config: Config, no_confirmation: bool, emulate: bool) -> None:
+    log_prefix = f"{from_address}->{to_address}"
+    fee = 5000
+    # get value
+    value = calcs.calc_sol_value(
+        nodes=config.nodes, value_str=config.value, address=from_address, proxies=config.proxies, log_prefix=log_prefix, fee=fee
+    )
+    if value is None:
+        return
+
+    # value_min_limit
+    if calcs.is_sol_value_less_min_limit(config.value_min_limit, value, log_prefix=log_prefix):
+        return
+
+    tx_params = {
+        "fee": fee,
+        "value": value,
+        "to": to_address,
+    }
+
+    # emulate?
+    if emulate:
+        msg = f"{log_prefix}: emulate, value={lamports_to_sol(value, config.round_ndigits)}SOL,"
+        msg += f" fee={fee}"
+        logger.info(msg)
+        return
+
+    logger.debug(f"{log_prefix}: tx_params={tx_params}")
+
+    res = transfer.transfer_sol_with_retries(
+        nodes=config.nodes,
+        from_address=from_address,
+        private_key=config.private_keys[from_address],
+        to_address=to_address,
+        lamports=value,
+        proxies=config.proxies,
+        retries=3,
+    )
+
+    if isinstance(res, Err):
+        logger.info(f"{log_prefix}: send_error: {res.err}")
+        return
+    signature = res.ok
+
+    if no_confirmation:
+        msg = f"{log_prefix}: sig={signature}, value={lamports_to_sol(value, config.round_ndigits)}"
+        logger.info(msg)
+    else:
+        logger.debug(f"{log_prefix}: sig={signature}, waiting for confirmation")
+        status = "UNKNOWN"
+        if _wait_confirmation(config, signature, log_prefix):
+            status = "OK"
+        msg = f"{log_prefix}: sig={signature}, value={lamports_to_sol(value, config.round_ndigits)}, status={status}"
+        logger.info(msg)
+
+
+def _wait_confirmation(config: Config, signature: Signature, log_prefix: str) -> bool:
+    count = 0
+    while True:
+        try:
+            node = mm_crypto_utils.random_node(config.nodes)
+            proxy = mm_crypto_utils.random_proxy(config.proxies)
+            client = get_client(node, proxy=proxy)
+            res = client.get_transaction(signature)
+            if res.value and res.value.slot:  # check for tx error
+                return True
+        except Exception as e:
+            logger.error(f"{log_prefix}: can't get confirmation, error={e}")
+        time.sleep(1)
+        count += 1
+        if count > 30:
+            logger.error(f"{log_prefix}: can't get confirmation, timeout")
+            return False

mm_sol/cli/cmd/wallet/keypair_cmd.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from mm_std import print_console
+from mm_std import print_json
 
 from mm_sol.account import (
     get_private_key_arr_str,
@@ -16,4 +16,4 @@ def run(private_key: str) -> None:
     public = get_public_key(private_key)
     private_base58 = get_private_key_base58(private_key)
     private_arr = get_private_key_arr_str(private_key)
-    print_console({"public": public, "private_base58": private_base58, "private_arr": private_arr}, print_json=True)
+    print_json({"public": public, "private_base58": private_base58, "private_arr": private_arr})

mm_sol/cli/cmd/wallet/new_cmd.py

@@ -1,4 +1,4 @@
-from mm_std import print_console
+from mm_std import print_json
 
 from mm_sol.account import generate_account, get_private_key_arr_str
 
@@ -11,4 +11,4 @@ def run(limit: int, array: bool) -> None:
         if array:
             private_key = get_private_key_arr_str(acc.private_key_base58)
         result[acc.public_key] = private_key
-    print_console(result, print_json=True)
+    print_json(result)

mm_sol/cli/examples/transfer-sol.yml

@@ -1,8 +1,11 @@
-from_address: ERB7SPx1XxH35pLu4Lkg9ChPQgsnwJGLZG8RsEE87XNw
-private_key: 3h92ZLyibvqQ9f923s66eN7V1iyG5WRRo3y9nciH4swUiLrkrYRdRM8q3DrtJ9JjTjiU9BT2r2qNzuiCmcZPVvqV
-amount: 1.2 # in SOL
-recipients:
-  - Rjg3K9PPDm1B5bmUP7eXZNfmApgvDPF9SrTh12dLRH9
+tx_routes: |
+  Bd8CxCTLez2ckVTqEJjuZkWjYFSRbo8fA1qYbd7yFVP9 Eaft9xXzfgbRqsHd65WspoaxTtH7pkznM9YA8tsDKGwj
+  Fc2TRJVCpFZpRz56mFnQETctib1zwFnwHcS7HoQSgUzZ EVJctTWikt29rUXBf49tyQdK87x837HtvpCwqeSjp1Ur
 
+
+private_keys_file: ./path/to/privates.txt
+value: 0.012 sol
+
+proxies_url: https://site.com/api/get-proxies
 nodes: |
-  https://api.mainnet-beta.solana.com
+  https://api.devnet.solana.com

mm_sol/cli/validators.py

@@ -0,0 +1,11 @@
+from mm_sol.cli import calcs
+
+
+def is_valid_var_lamports(value: str | None, base_name: str = "var", decimals: int | None = None) -> bool:
+    if value is None:
+        return True  # check for None on BaseModel.field type level
+    try:
+        calcs.calc_var_value(value, var_value=123, var_name=base_name, decimals=decimals)
+        return True  # noqa: TRY300
+    except ValueError:
+        return False

mm_sol/converters.py

@@ -0,0 +1,33 @@
+from decimal import Decimal
+
+
+def lamports_to_sol(lamports: int, ndigits: int = 4) -> Decimal:
+    return Decimal(str(round(lamports / 10**9, ndigits=ndigits)))
+
+
+def sol_to_lamports(sol: Decimal) -> int:
+    return int(sol * 10**9)
+
+
+def to_lamports(value: str | int | Decimal, decimals: int | None = None) -> int:
+    if isinstance(value, int):
+        return value
+    if isinstance(value, Decimal):
+        if value != value.to_integral_value():
+            raise ValueError(f"value must be integral number: {value}")
+        return int(value)
+    if isinstance(value, str):
+        value = value.lower().replace(" ", "").strip()
+        if value.endswith("sol"):
+            value = value.replace("sol", "")
+            return sol_to_lamports(Decimal(value))
+        if value.endswith("t"):
+            if decimals is None:
+                raise ValueError("t without decimals")
+            value = value.removesuffix("t")
+            return int(Decimal(value) * 10**decimals)
+        if value.isdigit():
+            return int(value)
+        raise ValueError("wrong value " + value)
+
+    raise ValueError(f"value has a wrong type: {type(value)}")

mm_sol/solana_cli.py

@@ -26,7 +26,6 @@ class StakeAccount(BaseModel):
     vote: str | None = Field(None, alias="delegatedVoteAccountAddress")
 
     @field_validator("balance")
-    @classmethod
     def from_lamports_to_sol(cls, v: int | None) -> float | None:
         if v:
             return v / 1_000_000_000
@@ -44,7 +43,6 @@ class Stake(BaseModel):
     lock_time: int | None = Field(None, alias="unixTimestamp")
 
     @field_validator("balance", "delegated", "active")
-    @classmethod
     def from_lamports_to_sol(cls, v: int | None) -> float | None:
         if v:
             return v / 1_000_000_000

mm_sol/token.py

@@ -1,77 +1,9 @@
+import mm_crypto_utils
+from mm_crypto_utils import Nodes, Proxies
 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.types import Nodes, Proxies
-from mm_sol.utils import get_client, get_node, get_proxy
-
-
-def get_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]:
-    try:
-        client = get_client(node, proxy=proxy, timeout=timeout)
-        if token_account:
-            res_balance = client.get_token_account_balance(Pubkey.from_string(token_account))
-            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)),
-        )
-
-        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_)
-            if res.value:  # type:ignore[truthy-bool]
-                balances.append(int(res.value.amount))
-
-        if len(balances) > 1:
-            return Err("there are many non empty token accounts, set token_account explicitly")
-        return Ok(balances[0])
-    except SolanaRpcException as e:
-        return Err(e.error_msg)
-    except Exception as e:
-        return Err(e)
-
-
-def get_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_balance(
-            get_node(nodes),
-            owner_address,
-            token_mint_address,
-            token_account,
-            timeout=timeout,
-            proxy=get_proxy(proxies),
-            no_token_accounts_return_zero=no_token_accounts_return_zero,
-        )
-        if res.is_ok():
-            return res
-    return res
+from mm_sol.utils import get_client
 
 
 def get_decimals(node: str, token_mint_address: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
@@ -88,46 +20,12 @@ def get_decimals_with_retries(
 ) -> Result[int]:
     res: Result[int] = Err("not started yet")
     for _ in range(retries):
-        res = get_decimals(get_node(nodes), token_mint_address, timeout=timeout, proxy=get_proxy(proxies))
+        res = get_decimals(
+            node=mm_crypto_utils.random_node(nodes),
+            token_mint_address=token_mint_address,
+            timeout=timeout,
+            proxy=mm_crypto_utils.random_proxy(proxies),
+        )
         if res.is_ok():
             return res
     return res
-
-
-# def transfer_to_wallet_address(
-#     *,
-#     node: str,
-#     private_key: str,
-#     recipient_wallet_address: str,
-#     token_mint_address: str,
-#     amount: int,
-# ) -> Result[str]:
-#     try:
-#         keypair = account.get_keypair(private_key)
-#         token_client = Token(Client(node), Pubkey.from_string(token_mint_address), program_id=TOKEN_PROGRAM_ID, payer=keypair)
-#
-#         # get from_token_account
-#         res = token_client.get_accounts(keypair.public_key)
-#         token_accounts = res["result"]["value"]
-#         if len(token_accounts) > 1:
-#             return Result(error="many_from_token_accounts", data=res)
-#         from_token_account = Pubkey.from_string(token_accounts[0]["pubkey"])
-#
-#         # get to_token_account
-#         res = token_client.get_accounts(Pubkey.from_string(recipient_wallet_address))
-#         token_accounts = res["result"]["value"]
-#         if len(token_accounts) > 1:
-#             return Result(error="many_to_token_accounts", data=res)
-#         elif len(token_accounts) == 1:
-#             to_token_account = Pubkey.from_string(token_accounts[0]["pubkey"])
-#         else:  # create a new to_token_account
-#             to_token_account = token_client.create_account(owner=Pubkey.from_string(recipient_wallet_address))
-#
-#         res = token_client.transfer(source=from_token_account, dest=to_token_account, owner=keypair, amount=amount)
-#         if res.get("result"):
-#             return Result(ok=res.get("result"), data=res)
-#         return Result(error="unknown_response", data=res)
-#     except RPCException as e:
-#         return Result(error="rcp_exception", data=str(e))
-#     except Exception as e:
-#         return Result(error="exception", data=str(e))

mm_sol/transfer.py

@@ -1,66 +1,165 @@
 from decimal import Decimal
 
+import mm_crypto_utils
 import pydash
+from mm_crypto_utils import Nodes, Proxies
 from mm_std import Err, Ok, Result
 from pydantic import BaseModel
-from solana.rpc.api import Client
 from solders.message import Message
 from solders.pubkey import Pubkey
+from solders.signature import Signature
 from solders.system_program import TransferParams, transfer
 from solders.transaction import Transaction
+from spl.token.client import Token
+from spl.token.constants import TOKEN_PROGRAM_ID
+from spl.token.instructions import get_associated_token_address
 
+import mm_sol.converters
 from mm_sol import rpc, utils
 from mm_sol.account import check_private_key, get_keypair
 
 
+def transfer_token(
+    *,
+    node: str,
+    token_mint_address: str | Pubkey,
+    from_address: str | Pubkey,
+    private_key: str,
+    to_address: str | Pubkey,
+    amount: Decimal,
+    decimals: int,
+    proxy: str | None = None,
+    timeout: float = 10,
+    create_token_account_if_not_exists: bool = True,
+) -> Result[Signature]:
+    acc = get_keypair(private_key)
+    if not check_private_key(from_address, private_key):
+        return Err("invalid_private_key")
+
+    from_address = utils.pubkey(from_address)
+    token_mint_address = utils.pubkey(token_mint_address)
+    to_address = utils.pubkey(to_address)
+
+    client = utils.get_client(node, proxy=proxy, timeout=timeout)
+    token_client = Token(conn=client, pubkey=token_mint_address, program_id=TOKEN_PROGRAM_ID, payer=acc)
+
+    recipient_token_account = get_associated_token_address(to_address, token_mint_address, token_program_id=TOKEN_PROGRAM_ID)
+    from_token_account = get_associated_token_address(from_address, token_mint_address, token_program_id=TOKEN_PROGRAM_ID)
+
+    data: list[object] = []
+
+    account_info_res = client.get_account_info(recipient_token_account)
+    if account_info_res.value is None:
+        if create_token_account_if_not_exists:
+            create_account_res = token_client.create_account(to_address, skip_confirmation=False)
+            data.append(create_account_res)
+        else:
+            return Err("no_token_account")
+
+    res = token_client.transfer_checked(
+        source=from_token_account,
+        dest=recipient_token_account,
+        owner=from_address,
+        amount=mm_sol.converters.sol_to_lamports(amount),
+        decimals=decimals,
+    )
+    data.append(res)
+
+    return Ok(res.value, data=data)
+
+
+def transfer_token_with_retries(
+    *,
+    nodes: Nodes,
+    token_mint_address: str | Pubkey,
+    from_address: str | Pubkey,
+    private_key: str,
+    to_address: str | Pubkey,
+    amount: Decimal,
+    decimals: int,
+    proxies: Proxies = None,
+    timeout: float = 10,
+    retries: int = 3,
+) -> Result[Signature]:
+    res: Result[Signature] = Err("not started yet")
+    for _ in range(retries):
+        res = transfer_token(
+            node=mm_crypto_utils.random_node(nodes),
+            token_mint_address=token_mint_address,
+            from_address=from_address,
+            private_key=private_key,
+            to_address=to_address,
+            amount=amount,
+            decimals=decimals,
+            proxy=mm_crypto_utils.random_proxy(proxies),
+            timeout=timeout,
+        )
+        if res.is_ok():
+            return res
+    return res
+
+
 def transfer_sol(
     *,
+    node: str,
     from_address: str,
-    private_key_base58: str,
-    recipient_address: str,
-    amount_sol: Decimal,
-    nodes: str | list[str] | None = None,
-    attempts: int = 3,
-) -> Result[str]:
-    acc = get_keypair(private_key_base58)
-    if not check_private_key(from_address, private_key_base58):
-        raise ValueError("from_address or private_key_base58 is invalid")
-
-    lamports = int(amount_sol * 10**9)
-    error = None
+    private_key: str,
+    to_address: str,
+    lamports: int,
+    proxy: str | None = None,
+    timeout: float = 10,
+) -> Result[Signature]:
+    acc = get_keypair(private_key)
+    if not check_private_key(from_address, private_key):
+        return Err("invalid_private_key")
+
+    client = utils.get_client(node, proxy=proxy, timeout=timeout)
     data = None
-    for _ in range(attempts):
-        try:
-            client = Client(utils.get_node(nodes))
-            # tx = Transaction(from_keypairs=[acc])
-            # ti = transfer(
-            #     TransferParams(from_pubkey=acc.pubkey(), to_pubkey=Pubkey.from_string(recipient_address), lamports=lamports),
-            # )
-            # tx.add(ti)
-            # res = client.send_legacy_transaction(tx, acc)
-            ixns = [
-                transfer(
-                    TransferParams(from_pubkey=acc.pubkey(), to_pubkey=Pubkey.from_string(recipient_address), lamports=lamports)
-                )
-            ]
-            msg = Message(ixns, acc.pubkey())
-            tx = Transaction([acc], msg, client.get_latest_blockhash().value.blockhash)
-            res = client.send_transaction(tx)
-            data = res.to_json()
-            return Ok(str(res.value), data=data)
-        except Exception as e:
-            error = e
-
-    return Err(error or "unknown", data=data)
-
-
-class TransferInfo(BaseModel):
+    try:
+        ixs = [transfer(TransferParams(from_pubkey=acc.pubkey(), to_pubkey=Pubkey.from_string(to_address), lamports=lamports))]
+        msg = Message(ixs, acc.pubkey())
+        tx = Transaction([acc], msg, client.get_latest_blockhash().value.blockhash)
+        res = client.send_transaction(tx)
+        data = res.to_json()
+        return Ok(res.value, data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def transfer_sol_with_retries(
+    *,
+    nodes: Nodes,
+    from_address: str,
+    private_key: str,
+    to_address: str,
+    lamports: int,
+    proxies: Proxies = None,
+    timeout: float = 10,
+    retries: int = 3,
+) -> Result[Signature]:
+    res: Result[Signature] = Err("not started yet")
+    for _ in range(retries):
+        res = transfer_sol(
+            node=mm_crypto_utils.random_node(nodes),
+            from_address=from_address,
+            private_key=private_key,
+            to_address=to_address,
+            lamports=lamports,
+            proxy=mm_crypto_utils.random_proxy(proxies),
+            timeout=timeout,
+        )
+        if res.is_ok():
+            return res
+    return res
+
+
+class SolTransferInfo(BaseModel):
     source: str
     destination: str
     lamports: int
 
 
-def find_transfers(node: str, tx_signature: str) -> Result[list[TransferInfo]]:
+def find_sol_transfers(node: str, tx_signature: str) -> Result[list[SolTransferInfo]]:
     res = rpc.get_transaction(node, tx_signature, encoding="jsonParsed")
     if res.is_err():
         return res  # type: ignore[return-value]
@@ -74,7 +173,7 @@ def find_transfers(node: str, tx_signature: str) -> Result[list[TransferInfo]]:
                 destination = pydash.get(ix, "parsed.info.destination")
                 lamports = pydash.get(ix, "parsed.info.lamports")
                 if source and destination and lamports:
-                    result.append(TransferInfo(source=source, destination=destination, lamports=lamports))
+                    result.append(SolTransferInfo(source=source, destination=destination, lamports=lamports))
         return Ok(result, data=res.data)
     except Exception as e:
         return Err(e, res.data)

mm_sol/utils.py

@@ -1,31 +1,6 @@
-import random
-from decimal import Decimal
-
 from solana.rpc.api import Client
 from solana.rpc.commitment import Commitment
-
-from mm_sol.rpc import DEFAULT_MAINNET_RPC
-from mm_sol.types import Nodes, Proxies
-
-
-def lamports_to_sol(lamports: int, ndigits: int = 4) -> Decimal:
-    return Decimal(str(round(lamports / 10**9, ndigits=ndigits)))
-
-
-def get_node(nodes: Nodes | None = None) -> str:
-    if nodes is None:
-        return DEFAULT_MAINNET_RPC
-    if isinstance(nodes, str):
-        return nodes
-    return random.choice(nodes)
-
-
-def get_proxy(proxies: Proxies) -> str | None:
-    if not proxies:
-        return None
-    if isinstance(proxies, str):
-        return proxies
-    return random.choice(proxies)
+from solders.pubkey import Pubkey
 
 
 def get_client(
@@ -36,3 +11,9 @@ def get_client(
     timeout: float = 10,
 ) -> Client:
     return Client(endpoint, commitment=commitment, extra_headers=extra_headers, timeout=timeout, proxy=proxy)
+
+
+def pubkey(value: str | Pubkey) -> Pubkey:
+    if isinstance(value, Pubkey):
+        return value
+    return Pubkey.from_string(value)

{mm_sol-0.2.5.dist-info → mm_sol-0.2.6.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.2.5
-Requires-Python: >=3.12
+Version: 0.2.6
+Requires-Python: >=3.13
 Requires-Dist: base58~=2.1.1
 Requires-Dist: jinja2>=3.1.5
-Requires-Dist: mm-std~=0.1.12
-Requires-Dist: solana~=0.36.2
+Requires-Dist: mm-crypto-utils>=0.0.13
+Requires-Dist: solana~=0.36.3
 Requires-Dist: typer>=0.15.1

mm_sol-0.2.6.dist-info/RECORD

@@ -0,0 +1,31 @@
+mm_sol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_sol/account.py,sha256=a0pt1tVdY1O2a4qmgfUd5nP-ftqv3ey0T-2ru5qtUWE,3222
+mm_sol/balance.py,sha256=Idx7h9yhRLbrIEDFCBI5QSHE7OT2pYWEZrbHj9XFrkM,3147
+mm_sol/block.py,sha256=4Lc4TANgpGvPflVumC9MR-3vIl1dedGyci3cgzczuds,1794
+mm_sol/converters.py,sha256=jY3wZeo1326z8M-AMS4OEzspRaGt4Tbk0y2SPI-oDFE,1153
+mm_sol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_sol/rpc.py,sha256=TspD_KZQp_KJDQzRknxaT8DR03okok26UWDQWF7Zflg,8031
+mm_sol/solana_cli.py,sha256=ig3OoTvmkrl7MFQSZjRHIraLSmtse0_9kn5Nsw8_zb0,8258
+mm_sol/token.py,sha256=RpXHeM3KBH7q9SUyY_U2dRAgLPC7YgumOTAqxxf_JtI,1046
+mm_sol/transfer.py,sha256=-76gSHbQGOZeOgVgo10QWjAcv_9mnGrBNvpRCvXBlZQ,5872
+mm_sol/utils.py,sha256=NE0G564GiT9d7rW_lPPxUb1eq62WiXh28xtvtzNQIqw,556
+mm_sol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_sol/cli/calcs.py,sha256=1IQF1j6c9mRBH7UAnX-MwrCC4PJ3Vp1pg9haa2kG22I,3698
+mm_sol/cli/cli.py,sha256=9rWEDAd1iAwJYnC7voTo4ltqMtRd9IuHoGTmqwmDL8Q,3627
+mm_sol/cli/cli_utils.py,sha256=EJTWdccXg8mvkK7E-Dt7zmULzc1WoqFlbu8ASGT2SVI,1381
+mm_sol/cli/validators.py,sha256=RFbkSl67g6CXJJhgkNi0wvx_iXjXyQEqX5GmNYatshk,407
+mm_sol/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_sol/cli/cmd/balance_cmd.py,sha256=DfUZY3-Hr-F7Y0xp1faol0yLnPu6iDU3b839VhdwAbw,2587
+mm_sol/cli/cmd/balances_cmd.py,sha256=rnsomOKu1_BsRGYvbjTSXVKQ1pqzv4F0fIAnHMjp9kk,2639
+mm_sol/cli/cmd/example_cmd.py,sha256=bK_z4du0UPGAoiHnYdi6iaZim_kKlYw4NKBbzvyes28,221
+mm_sol/cli/cmd/node_cmd.py,sha256=2AEAjq2M9f8-RZiI0rif6wITdns9QUb4Kr34QPsI2CA,238
+mm_sol/cli/cmd/transfer_sol_cmd.py,sha256=vz2_yHmx0cFCD60ubgwru9seABJN71146vW8c-fPtew,6991
+mm_sol/cli/cmd/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_sol/cli/cmd/wallet/keypair_cmd.py,sha256=cRHVVTs9zNYmUozZ8ZlJoutn9V6r8I1AEHBrszR7dTE,538
+mm_sol/cli/cmd/wallet/new_cmd.py,sha256=hcP9NZPkwYkTBEvT5rBntFtCIvx1QnPGn5FUDnvz5sM,425
+mm_sol/cli/examples/balances.yml,sha256=SoFcf_IhgA2zrbihrVpqm-ikes80wLFGVzafrjO00UY,290
+mm_sol/cli/examples/transfer-sol.yml,sha256=YFIM36NhaSEPeck6yQMvcgy3MWxgsfDqmMLRqz6P1dk,346
+mm_sol-0.2.6.dist-info/METADATA,sha256=UVHWer8SaDg55zgUGXeoXXORcQuuakRCfiFGQ9msbYY,230
+mm_sol-0.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_sol-0.2.6.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.2.6.dist-info/RECORD,,

mm_sol/types.py

@@ -1,4 +0,0 @@
-from collections.abc import Sequence
-
-type Proxies = str | Sequence[str] | None
-type Nodes = str | Sequence[str]

mm_sol-0.2.5.dist-info/RECORD

@@ -1,29 +0,0 @@
-mm_sol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/account.py,sha256=WlcbPsRpseC507J3E_G-A2-PJGUToNqzSGjrg0pc-B8,3144
-mm_sol/balance.py,sha256=QzLjzW2fCGH9Uo8gjxerUnwCStsbkVrguXdPs5N6R5I,667
-mm_sol/block.py,sha256=4Lc4TANgpGvPflVumC9MR-3vIl1dedGyci3cgzczuds,1794
-mm_sol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/rpc.py,sha256=TspD_KZQp_KJDQzRknxaT8DR03okok26UWDQWF7Zflg,8031
-mm_sol/solana_cli.py,sha256=odXNPe8G7dvsGcZxujAFjkd0vWM6fdVvt_mzPulgDZQ,8292
-mm_sol/token.py,sha256=LpFnmTzbtKo_Z5hWX96k1Z153640N8VzXHCvsH5zArs,4903
-mm_sol/transfer.py,sha256=Bdh3amO-sO180Clq5RVgB9y7NXHhu1EbFNgEsGzHjFY,2911
-mm_sol/types.py,sha256=vXXP5Dc72BpHv5tsyws0KDZebG1W1-5HH0UjL7N2Mgc,113
-mm_sol/utils.py,sha256=tjV2d6ZZ-Z61cS0WWTPX2yZ2VoJUQv11CNW0p3nO54M,1016
-mm_sol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/cli.py,sha256=l3AKhrgO6GEFrwh3gov9_cfjyFZY0VbZGc0o7NqUWrU,3078
-mm_sol/cli/cli_utils.py,sha256=bOrU1LFgndBv4hlNNviHQOob3NfiOsS5YWWDm6fzpCs,1032
-mm_sol/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/cmd/balance_cmd.py,sha256=IryMXq_8yGF9lDXO5kmUo6TRGgedl_9rS3bE1iRPTw0,2516
-mm_sol/cli/cmd/balances_cmd.py,sha256=x6PdXqZgkSmHAsbxim06T4_iPbihUIB4GLy0ZPy5t0s,2168
-mm_sol/cli/cmd/example_cmd.py,sha256=bK_z4du0UPGAoiHnYdi6iaZim_kKlYw4NKBbzvyes28,221
-mm_sol/cli/cmd/node_cmd.py,sha256=UKlZZzd8MVfQHqAjigJRwPj95Mwq2cpHfWgH8BVuwaw,242
-mm_sol/cli/cmd/transfer_sol_cmd.py,sha256=Ta3H4TXxlCCKgcedphN6PU90iYQiZvmYYuKPO044ciw,1196
-mm_sol/cli/cmd/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/cmd/wallet/keypair_cmd.py,sha256=7Dk2eT6hfWRLI0uHO_rAQS8xRwY2S6Uk4iBEIO9aQ_w,561
-mm_sol/cli/cmd/wallet/new_cmd.py,sha256=nvFy5lkk8XUM5jchx0rn0aHHQ0LGVgbwpn7-kej9ccI,448
-mm_sol/cli/examples/balances.yml,sha256=SoFcf_IhgA2zrbihrVpqm-ikes80wLFGVzafrjO00UY,290
-mm_sol/cli/examples/transfer-sol.yml,sha256=fEf5lxnotLwQHt85JzwN0o6kax_Am88VKH5e-n1HP94,290
-mm_sol-0.2.5.dist-info/METADATA,sha256=CARYWN8yylvN_Py6sDi3DBhOcrMlXja6IPlK-LxoiF4,221
-mm_sol-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_sol-0.2.5.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
-mm_sol-0.2.5.dist-info/RECORD,,