mm-sol 0.3.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

mm_sol/cli/cli.py

@@ -8,12 +8,15 @@ from mm_std import print_plain
 from mm_sol.account import PHANTOM_DERIVATION_PATH
 
 from . import cli_utils
-from .cmd import balance_cmd, balances_cmd, example_cmd, node_cmd, transfer_sol_cmd, transfer_token_cmd
+from .cmd import balance_cmd, balances_cmd, example_cmd, node_cmd, transfer_cmd
+from .cmd.transfer_cmd import TransferCmdParams
 from .cmd.wallet import keypair_cmd, mnemonic_cmd
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
-wallet_app = typer.Typer(no_args_is_help=True, help="Wallet commands: generate new accounts, private to address")
+wallet_app = typer.Typer(
+    no_args_is_help=True, help="Wallet-related commands: generate new accounts, derive addresses from private keys, and more"
+)
 app.add_typer(wallet_app, name="wallet")
 app.add_typer(wallet_app, name="w", hidden=True)
 
@@ -31,11 +34,10 @@ def main(_version: bool = typer.Option(None, "--version", callback=version_callb
 
 class ConfigExample(str, Enum):
     balances = "balances"
-    transfer_sol = "transfer-sol"
-    transfer_token = "transfer-token"  # noqa: S105 # nosec
+    transfer = "transfer"
 
 
-@app.command(name="example", help="Print an example of config for a command")
+@app.command(name="example", help="Displays an example configuration for a command")
 def example_command(command: Annotated[ConfigExample, typer.Argument()]) -> None:
     example_cmd.run(command.value)
 
@@ -51,52 +53,39 @@ def balance_command(
     balance_cmd.run(rpc_url, wallet_address, token_address, lamport, proxies_url)
 
 
-@app.command(name="balances", help="Print SOL and token balances for accounts")
+@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)
 
 
-@app.command(name="transfer-sol", help="Transfer SOL from one or many accounts")
-def transfer_sol_command(
+@app.command(name="transfer", help="Transfers SOL or SPL tokens, supporting multiple routes, delays, and expression-based values")
+def transfer_command(
     config_path: Path,
     print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances and exit"),
+    print_transfers: bool = typer.Option(False, "--transfers", "-t", help="Print transfers (from, to, value) and exit"),
     print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    config_verbose: bool = typer.Option(False, "--config-verbose", help="Print config in verbose mode 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,
+    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,
+        )
     )
 
 
-@app.command(name="transfer-token", help="Transfer token from one or many accounts")
-def transfer_token_command(
-    config_path: Path,
-    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_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")
+@app.command(name="node", help="Checks RPC URLs for availability and status")
 def node_command(
     urls: Annotated[list[str], typer.Argument()],
     proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,

mm_sol/cli/cli_utils.py

@@ -1,9 +1,12 @@
 import importlib.metadata
 import time
+from pathlib import Path
 
 import mm_crypto_utils
 from loguru import logger
 from mm_crypto_utils import Nodes, Proxies
+from mm_std import BaseConfig, print_json
+from pydantic import BaseModel
 from solders.signature import Signature
 
 from mm_sol.utils import get_client
@@ -13,6 +16,19 @@ def get_version() -> str:
     return importlib.metadata.version("mm-sol")
 
 
+class BaseConfigParams(BaseModel):
+    config_path: Path
+    print_config_and_exit: bool
+
+
+def print_config(config: BaseConfig, exclude: set[str] | None = None, count: set[str] | None = None) -> None:
+    data = config.model_dump(exclude=exclude)
+    if count:
+        for k in count:
+            data[k] = len(data[k])
+    print_json(data)
+
+
 def public_rpc_url(url: str | None) -> str:
     if not url:
         return "https://api.mainnet-beta.solana.com"

mm_sol/cli/cmd/transfer_cmd.py

@@ -0,0 +1,271 @@
+import sys
+import time
+from pathlib import Path
+from typing import Annotated, Self
+
+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 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.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
+
+
+class Config(BaseConfig):
+    nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
+    transfers: Annotated[list[Transfer], BeforeValidator(Validators.sol_transfers())]
+    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.sol_private_keys())]
+    proxies: Annotated[list[str], Field(default_factory=list), BeforeValidator(Validators.proxies())]
+    token: Annotated[str | None, AfterValidator(Validators.sol_address())] = None
+    token_decimals: int = -1
+    default_value: Annotated[str | None, AfterValidator(Validators.valid_sol_or_token_expression("balance"))] = None
+    value_min_limit: Annotated[str | None, AfterValidator(Validators.valid_sol_or_token_expression())] = None
+    delay: Annotated[str | None, AfterValidator(Validators.valid_calc_decimal_value())] = None  # in seconds
+    round_ndigits: int = 5
+    log_debug: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
+    log_info: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
+
+    @property
+    def from_addresses(self) -> list[str]:
+        return [r.from_address for r in self.transfers]
+
+    @model_validator(mode="after")
+    def final_validator(self) -> Self:
+        if not self.private_keys.contains_all_addresses(self.from_addresses):
+            raise ValueError("private keys are not set for all addresses")
+
+        for transfer in self.transfers:  # If value is not set for a transfer, then set it to the global value of the config.
+            if not transfer.value and self.default_value:
+                transfer.value = self.default_value
+        for transfer in self.transfers:  # Check all transfers have a value.
+            if not transfer.value:
+                raise ValueError(f"{transfer.log_prefix}: value is not set")
+
+        if self.token:
+            if self.default_value:
+                Validators.valid_token_expression("balance")(self.default_value)
+            if self.value_min_limit:
+                Validators.valid_token_expression()(self.value_min_limit)
+        else:
+            if self.default_value:
+                Validators.valid_sol_expression("balance")(self.default_value)
+            if self.value_min_limit:
+                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
+
+        return self
+
+
+class TransferCmdParams(BaseConfigParams):
+    print_balances: bool
+    print_transfers: bool
+    debug: bool
+    no_confirmation: bool
+    emulate: bool
+    print_config_verbose: bool
+
+
+def run(cmd_params: TransferCmdParams) -> None:
+    config = Config.read_toml_config_or_exit(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"})
+        sys.exit(0)
+
+    if cmd_params.print_transfers:
+        _print_transfers(config)
+        sys.exit(0)
+
+    if cmd_params.print_balances:
+        _print_balances(config)
+        sys.exit(0)
+
+    _run_transfers(config, cmd_params)
+
+
+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)
+        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))
+    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:
+    if config.token:
+        value_res = calcs.calc_token_value_for_address(
+            nodes=config.nodes,
+            value_expression=transfer.value,
+            wallet_address=transfer.from_address,
+            proxies=config.proxies,
+            token_mint_address=config.token,
+            token_decimals=config.token_decimals,
+        )
+    else:
+        value_res = 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}")
+
+    return value_res.ok
+
+
+def _check_value_min_limit(transfer: Transfer, value: int, config: Config) -> bool:
+    """Returns False if the transfer should be skipped."""
+    if config.value_min_limit:
+        if config.token:
+            value_min_limit = calcs.calc_token_expression(config.value_min_limit, config.token_decimals)
+        else:
+            value_min_limit = calcs.calc_sol_expression(config.value_min_limit)
+        if value < value_min_limit:
+            logger.info(f"{transfer.log_prefix}: value<value_min_limit, value={_value_with_suffix(value, config)}")
+    return True
+
+
+def _value_with_suffix(value: int, config: Config) -> str:
+    if config.token:
+        return f"{to_token(value, decimals=config.token_decimals, ndigits=config.round_ndigits)}t"
+    return f"{lamports_to_sol(value, config.round_ndigits)}sol"
+
+
+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,
+            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,
+            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}")
+        return None
+    return res.ok
+
+
+def _transfer(transfer: Transfer, config: Config, cmd_params: TransferCmdParams) -> None:
+    transfer_sol_fee = 5000
+
+    value = _calc_value(transfer, config, transfer_sol_fee)
+    if value is None:
+        return
+
+    if not _check_value_min_limit(transfer, value, config):
+        return
+
+    if cmd_params.emulate:
+        logger.info(f"{transfer.log_prefix}: emulate, value={_value_with_suffix(value, config)}")
+        return
+
+    signature = _send_tx(transfer, value, config)
+    if signature is None:
+        return
+
+    status = "UNKNOWN"
+    if not cmd_params.no_confirmation:
+        logger.debug(f"{transfer.log_prefix}: waiting for confirmation, sig={signature}")
+        if cli_utils.wait_confirmation(config.nodes, config.proxies, signature, transfer.log_prefix):
+            status = "OK"
+
+    logger.info(f"{transfer.log_prefix}: sig={signature}, value={_value_with_suffix(value, config)}, status={status}")
+
+
+def _print_transfers(config: Config) -> None:
+    table = Table("n", "from_address", "to_address", "value", title="transfers")
+    for count, transfer in enumerate(config.transfers, start=1):
+        table.add_row(str(count), transfer.from_address, transfer.to_address, transfer.value)
+    console = Console()
+    console.print(table)
+
+
+def _print_balances(config: Config) -> None:
+    if config.token:
+        headers = ["n", "from_address", "sol", "t", "to_address", "sol", "t"]
+    else:
+        headers = ["n", "from_address", "sol", "to_address", "sol"]
+    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 ""
+
+            if config.token:
+                table.add_row(
+                    str(count),
+                    route.from_address,
+                    from_sol_balance,
+                    from_t_balance,
+                    route.to_address,
+                    to_sol_balance,
+                    to_t_balance,
+                )
+            else:
+                table.add_row(
+                    str(count),
+                    route.from_address,
+                    from_sol_balance,
+                    route.to_address,
+                    to_sol_balance,
+                )
+
+
+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)),
+    )
+
+
+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)),
+    )

mm_sol/cli/examples/balances.toml

@@ -2,9 +2,11 @@ accounts = """
 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM # binance
 61aq585V8cR2sZBeawJFt2NPqmN7zDi1sws4KLs5xHXV # Jupiter cold wallet
 """
+
 tokens = """
 EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v # USDC
 JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN # JUP
 """
+
 nodes = "https://api.mainnet-beta.solana.com"
 # proxies = "env_url: MM_SOL_PROXIES_URL"

mm_sol/cli/examples/transfer.toml

@@ -0,0 +1,35 @@
+# Each line is a transfer instruction, with format: from_address to_address [value]
+# Value is optional. If value is not set, default_value will be used
+# value is an expression that can contain variable 'balance' and 'random' function
+transfers = """
+# for sol transfer use 'sol' suffix, example: 1.2sol. For other tokens use 't' suffix, example: 1.2t
+Bd8CxCTLez2ckVTqEJjuZkWjYFSRbo8fA1qYbd7yFVP9 Eaft9xXzfgbRqsHd65WspoaxTtH7pkznM9YA8tsDKGwj 1.2t 
+Fc2TRJVCpFZpRz56mFnQETctib1zwFnwHcS7HoQSgUzZ EVJctTWikt29rUXBf49tyQdK87x837HtvpCwqeSjp1Ur 0.6balance-random(1t,2.50t)-100
+6TW4WswDgGmEB5HELBtEdwC1tQJq9Xa1msDjPw94sgai GGb7gb5EzW8GZZWX552eiC9r1SY4Pqtgbqf9UMrBrEzy # default_value will be used
+file: /path/to/other/transfers.txt # transfers from this file will be added
+"""
+
+token = "6VBTMLgv256c7scudNf8T5GoTJcEE8WfgcJhxbGYPQ8G" # if token is not specified, then SOL is used
+
+private_keys = """
+5VTfgpKKkckrsK33vcw6cEgv8SjLiwaorU8sd2ftjo2sx4tCV6N44dF4P9VigLaKNT2vpX3VuiFAiNpEBnMq3CiB
+DE9poAKvs6tENFbADZ25W1zfKeiCbuDnFbafkBgo4rT28ZGkemqnF1zAqX9WGvBKUXSRVhXgX1RHe3qn11xfjR8
+file: ./path/to/privates.txt
+# Extra keys are not a problem, nor is their order.
+"""
+
+# default_value is used if transfer.value is not set in transfers. It's optional.
+default_value = "0.2balance+random(1t,2.50t)-100" # If transferring SOL, the suffix ‘sol’ is used. For any other tokens, the suffix ‘t’ is used.
+
+delay = "random(10, 100)" # seconds, optional
+
+proxies = """
+http://usr:pass@123.123.123.123:1234
+env_url: MM_SOL_PROXIES_URL
+url: https://site.com/api/proxies
+"""
+
+nodes = """
+https://api.devnet.solana.com
+http://localhost:8899
+"""

mm_sol/cli/validators.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable
 
-from mm_crypto_utils import AddressToPrivate, ConfigValidators, TxRoute
+from mm_crypto_utils import AddressToPrivate, ConfigValidators, Transfer
 
 from mm_sol.account import get_public_key, is_address
 from mm_sol.constants import SUFFIX_DECIMALS
@@ -16,8 +16,8 @@ class Validators(ConfigValidators):
         return ConfigValidators.addresses(unique, is_address=is_address)
 
     @staticmethod
-    def sol_routes() -> Callable[[str], list[TxRoute]]:
-        return ConfigValidators.routes(is_address)
+    def sol_transfers() -> Callable[[str], list[Transfer]]:
+        return ConfigValidators.transfers(is_address)
 
     @staticmethod
     def sol_private_keys() -> Callable[[str], AddressToPrivate]:
@@ -30,3 +30,7 @@ class Validators(ConfigValidators):
     @staticmethod
     def valid_token_expression(var_name: str | None = None) -> Callable[[str], str]:
         return ConfigValidators.valid_calc_int_expression(var_name, {"t": 6})
+
+    @staticmethod
+    def valid_sol_or_token_expression(var_name: str | None = None) -> Callable[[str], str]:
+        return ConfigValidators.valid_calc_int_expression(var_name, SUFFIX_DECIMALS | {"t": 6})

{mm_sol-0.3.6.dist-info → mm_sol-0.5.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.3.6
+Version: 0.5.0
 Requires-Python: >=3.12
 Requires-Dist: base58~=2.1.1
 Requires-Dist: jinja2>=3.1.5
-Requires-Dist: mm-crypto-utils>=0.1.4
+Requires-Dist: mm-crypto-utils>=0.2.3
 Requires-Dist: mnemonic==0.21
-Requires-Dist: solana~=0.36.3
+Requires-Dist: solana~=0.36.5
 Requires-Dist: typer>=0.15.1

{mm_sol-0.3.6.dist-info → mm_sol-0.5.0.dist-info}/RECORD

@@ -12,23 +12,21 @@ mm_sol/transfer.py,sha256=taf2NTLpo-bxISeaILARXEGLldUvqvP-agp5IDva7Hw,5825
 mm_sol/utils.py,sha256=NE0G564GiT9d7rW_lPPxUb1eq62WiXh28xtvtzNQIqw,556
 mm_sol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_sol/cli/calcs.py,sha256=-r9RlsQyOziTDf84uIsvTgZmsUdNrVeazu3vTj9hhNA,1887
-mm_sol/cli/cli.py,sha256=OlgBas-dWWZJ_WCbHJGLX6GxfILvIy7Q0VhgRo_nytE,4945
-mm_sol/cli/cli_utils.py,sha256=HCMnOhMSQtAGQpZaA2e5v_li-XNDv4P3LxBcSSTPDoo,1399
-mm_sol/cli/validators.py,sha256=HLCFRrBOdyAMj_ibdAkkP36y9Zm2Dt3gMKoyPOcaiQE,1164
+mm_sol/cli/cli.py,sha256=a28Cy1X2bRSIAAJu2HHoPoTJYOPvff-anVcL0BJnwRI,4610
+mm_sol/cli/cli_utils.py,sha256=nFdY8tJFZxyssEBEFCc3VTNJt447e6vMnugx4GBPL4o,1840
+mm_sol/cli/validators.py,sha256=M_Rr7JoG3TUYTDAGkjQLDH6l9i9FOrSpss30KdY3UlM,1379
 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=gMRZXAnCOPESsKRqz33ALPzSOqGGeZF225kMRO6sV-c,2876
 mm_sol/cli/cmd/example_cmd.py,sha256=M5dvRg9jvpVUwxvMRiRnO77aKR7c57bMY9booxMAswM,222
 mm_sol/cli/cmd/node_cmd.py,sha256=2AEAjq2M9f8-RZiI0rif6wITdns9QUb4Kr34QPsI2CA,238
-mm_sol/cli/cmd/transfer_sol_cmd.py,sha256=CfCQ3SsXzdd2Yy3awlM2l7D1LuCNnSUg_Y84ttpL9-Q,6155
-mm_sol/cli/cmd/transfer_token_cmd.py,sha256=gepB8dds1xnGMYT1UBwV8EgpKmST3SvWS99lXnc2X3E,7470
+mm_sol/cli/cmd/transfer_cmd.py,sha256=eQzD7LispR4KFMUlXdXMBGbXs7b0A-iHJHs7VkxH1UA,11021
 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/mnemonic_cmd.py,sha256=IiON_fJT5AFfIr_E1LR6_iDYZ3c_jWCFc-wSYqk61V8,648
-mm_sol/cli/examples/balances.toml,sha256=jyfUXusAWe6suuuwnPIfqWdU2kfT3hfMjkZ6uYMg8s0,347
-mm_sol/cli/examples/transfer-sol.toml,sha256=7y_F2Kd-x05zbJ4Uw6NYegIXaZES5v96WQY8JKVpuwY,388
-mm_sol/cli/examples/transfer-token.toml,sha256=I_Wof-APv-h6xeYVq0zbWfLbpDny2kz9U0xJifVNEtU,401
-mm_sol-0.3.6.dist-info/METADATA,sha256=XcbspoW4fU3UlQLdVu6Z9rN-LELguqgfv_U2AGJr9js,259
-mm_sol-0.3.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_sol-0.3.6.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
-mm_sol-0.3.6.dist-info/RECORD,,
+mm_sol/cli/examples/balances.toml,sha256=333g2EkyYBDW7OWFGMIWVZGkdFQMMo0Ag-bg-BvS4Zg,349
+mm_sol/cli/examples/transfer.toml,sha256=kOCdmuwmhlOam4LVtlcYTKF0PoZYHWMlv9gWxNSXMOk,1624
+mm_sol-0.5.0.dist-info/METADATA,sha256=oszZ4Bv24rOTDdMZf6y5FugE0yCiSqANtii1_NluRKc,259
+mm_sol-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_sol-0.5.0.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.5.0.dist-info/RECORD,,

mm_sol/cli/cmd/transfer_sol_cmd.py

@@ -1,159 +0,0 @@
-import sys
-import time
-from pathlib import Path
-from typing import Annotated, Self
-
-import mm_crypto_utils
-from loguru import logger
-from mm_crypto_utils import AddressToPrivate, TxRoute
-from mm_std import BaseConfig, Err, utc_now
-from pydantic import AfterValidator, BeforeValidator, Field, model_validator
-from rich.live import Live
-from rich.table import Table
-
-from mm_sol import transfer
-from mm_sol.balance import get_sol_balance_with_retries
-from mm_sol.cli import calcs, cli_utils
-from mm_sol.cli.calcs import calc_sol_expression
-from mm_sol.cli.validators import Validators
-from mm_sol.converters import lamports_to_sol
-
-
-# noinspection DuplicatedCode
-class Config(BaseConfig):
-    nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
-    routes: Annotated[list[TxRoute], BeforeValidator(Validators.sol_routes())]
-    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.sol_private_keys())]
-    proxies: Annotated[list[str], Field(default_factory=list), BeforeValidator(Validators.proxies())]
-    value: Annotated[str, AfterValidator(Validators.valid_sol_expression("balance"))]
-    value_min_limit: Annotated[str | None, AfterValidator(Validators.valid_sol_expression())] = None
-    delay: Annotated[str | None, AfterValidator(Validators.valid_calc_decimal_value())] = None  # in seconds
-    round_ndigits: int = 5
-    log_debug: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
-    log_info: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
-
-    @property
-    def from_addresses(self) -> list[str]:
-        return [r.from_address for r in self.routes]
-
-    @model_validator(mode="after")
-    def final_validator(self) -> Self:
-        if not self.private_keys.contains_all_addresses(self.from_addresses):
-            raise ValueError("private keys are not set for all addresses")
-
-        return self
-
-
-def run(
-    config_path: Path,
-    *,
-    print_balances: bool,
-    print_config: bool,
-    debug: bool,
-    no_confirmation: bool,
-    emulate: bool,
-) -> None:
-    config = Config.read_toml_config_or_exit(config_path)
-
-    if print_config:
-        config.print_and_exit({"private_keys"})
-
-    mm_crypto_utils.init_logger(debug, config.log_debug, config.log_info)
-
-    if print_balances:
-        _print_balances(config)
-        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'}) | {'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,
-        )
-        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_res = calcs.calc_sol_value_for_address(
-        nodes=config.nodes, value_expression=config.value, address=from_address, proxies=config.proxies, fee=fee
-    )
-    logger.debug(f"{log_prefix}value={value_res.ok_or_err()}")
-    if isinstance(value_res, Err):
-        logger.info(f"{log_prefix}calc value error, {value_res.err}")
-        return
-    value = value_res.ok
-
-    # value_min_limit
-    if config.value_min_limit:
-        value_min_limit = calc_sol_expression(config.value_min_limit)
-        if value < value_min_limit:
-            logger.info(f"{log_prefix}: value<value_min_limit, value={lamports_to_sol(value, config.round_ndigits)}sol")
-            return
-
-    # 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
-
-    debug_tx_params = {"fee": fee, "value": value, "to": to_address}
-    logger.debug(f"{log_prefix}: tx_params={debug_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 cli_utils.wait_confirmation(config.nodes, config.proxies, 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 _print_balances(config: Config) -> None:
-    table = Table("n", "from_address", "sol", "to_address", "sol", title="balances")
-    with Live(table, refresh_per_second=0.5):
-        for count, route in enumerate(config.routes):
-            from_balance = _get_sol_balance_str(route.from_address, config)
-            to_balance = _get_sol_balance_str(route.to_address, config)
-            row: list[str] = [str(count), route.from_address, from_balance, route.to_address, to_balance]
-            table.add_row(*row)
-
-
-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)),
-    )

mm_sol/cli/cmd/transfer_token_cmd.py

@@ -1,188 +0,0 @@
-import sys
-import time
-from pathlib import Path
-from typing import Annotated, Self
-
-import mm_crypto_utils
-from loguru import logger
-from mm_crypto_utils import AddressToPrivate, TxRoute
-from mm_std import BaseConfig, Err, fatal, utc_now
-from pydantic import AfterValidator, BeforeValidator, Field, model_validator
-from rich.live import Live
-from rich.table import Table
-
-from mm_sol import transfer
-from mm_sol.balance import get_sol_balance_with_retries, get_token_balance_with_retries
-from mm_sol.cli import calcs, cli_utils
-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
-
-
-# noinspection DuplicatedCode
-class Config(BaseConfig):
-    nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
-    routes: Annotated[list[TxRoute], BeforeValidator(Validators.sol_routes())]
-    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.sol_private_keys())]
-    proxies: Annotated[list[str], Field(default_factory=list), BeforeValidator(Validators.proxies())]
-    token: Annotated[str, AfterValidator(Validators.sol_address())]
-    value: Annotated[str, AfterValidator(Validators.valid_token_expression("balance"))]
-    value_min_limit: Annotated[str | None, AfterValidator(Validators.valid_token_expression())] = None
-    delay: Annotated[str | None, AfterValidator(Validators.valid_calc_decimal_value())] = None  # in seconds
-    round_ndigits: int = 5
-    log_debug: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
-    log_info: Annotated[Path | None, BeforeValidator(Validators.log_file())] = None
-
-    @property
-    def from_addresses(self) -> list[str]:
-        return [r.from_address for r in self.routes]
-
-    @model_validator(mode="after")
-    def final_validator(self) -> Self:
-        if not self.private_keys.contains_all_addresses(self.from_addresses):
-            raise ValueError("private keys are not set for all addresses")
-
-        return self
-
-
-def run(
-    config_path: Path,
-    *,
-    print_balances: bool,
-    print_config: bool,
-    debug: bool,
-    no_confirmation: bool,
-    emulate: bool,
-) -> None:
-    config = Config.read_toml_config_or_exit(config_path)
-
-    if print_config:
-        config.print_and_exit({"private_keys"})
-
-    mm_crypto_utils.init_logger(debug, config.log_debug, config.log_info)
-
-    decimals_res = get_decimals_with_retries(config.nodes, config.token, retries=3, proxies=config.proxies)
-    if isinstance(decimals_res, Err):
-        fatal(f"can't get decimals for token={config.token}, error={decimals_res.err}")
-
-    token_decimals = decimals_res.ok
-    logger.debug(f"token decimals={token_decimals}")
-
-    if print_balances:
-        _print_balances(config, token_decimals)
-        sys.exit(0)
-
-    _run_transfers(config, token_decimals, no_confirmation=no_confirmation, emulate=emulate)
-
-
-def _run_transfers(config: Config, token_decimals: int, *, no_confirmation: bool, emulate: bool) -> None:
-    logger.info(f"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.routes):
-        _transfer(
-            route=route,
-            token_decimals=token_decimals,
-            config=config,
-            no_confirmation=no_confirmation,
-            emulate=emulate,
-        )
-        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(*, route: TxRoute, config: Config, token_decimals: int, no_confirmation: bool, emulate: bool) -> None:
-    log_prefix = f"{route.from_address}->{route.to_address}"
-    fee = 5000
-
-    # get value
-    value_res = calcs.calc_token_value_for_address(
-        nodes=config.nodes,
-        value_expression=config.value,
-        wallet_address=route.from_address,
-        proxies=config.proxies,
-        token_mint_address=config.token,
-        token_decimals=token_decimals,
-    )
-    logger.debug(f"{log_prefix}: value={value_res.ok_or_err()}")
-    if isinstance(value_res, Err):
-        logger.info(f"{log_prefix}: calc value error, {value_res.err}")
-        return
-    value = value_res.ok
-    value_t = f"{to_token(value, decimals=token_decimals, ndigits=config.round_ndigits)}t"
-
-    # value_min_limit
-    if config.value_min_limit:
-        value_min_limit = calcs.calc_token_expression(config.value_min_limit, token_decimals)
-        if value < value_min_limit:
-            logger.info(f"{log_prefix}: value<value_min_limit, value={value_t}")
-            return
-
-    if emulate:
-        logger.info(f"{log_prefix}: emulate, value={value_t}, fee={fee}lamports")
-        return
-
-    logger.debug(f"{log_prefix}: value={to_token(value, decimals=token_decimals)}t, fee={fee}lamports")
-    res = transfer.transfer_token_with_retries(
-        nodes=config.nodes,
-        token_mint_address=config.token,
-        from_address=route.from_address,
-        private_key=config.private_keys[route.from_address],
-        to_address=route.to_address,
-        amount=value,
-        decimals=token_decimals,
-        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={value_t}"
-        logger.info(msg)
-    else:
-        logger.debug(f"{log_prefix}: sig={signature}, waiting for confirmation")
-        status = "UNKNOWN"
-        if cli_utils.wait_confirmation(config.nodes, config.proxies, signature, log_prefix):
-            status = "OK"
-        msg = f"{log_prefix}: sig={signature}, value={value_t}, status={status}"
-        logger.info(msg)
-
-
-def _print_balances(config: Config, token_decimals: int) -> None:
-    table = Table("n", "from_address", "sol", "t", "to_address", "sol", "t", title="balances")
-    with Live(table, refresh_per_second=0.5):
-        for count, route in enumerate(config.routes):
-            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, token_decimals)
-            to_t_balance = _get_token_balance_str(route.to_address, config, token_decimals)
-            row: list[str] = [
-                str(count),
-                route.from_address,
-                from_sol_balance,
-                from_t_balance,
-                route.to_address,
-                to_sol_balance,
-                to_t_balance,
-            ]
-            table.add_row(*row)
-
-
-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)),
-    )
-
-
-def _get_token_balance_str(address: str, config: Config, token_decimals: int) -> str:
-    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, token_decimals, ndigits=config.round_ndigits)),
-    )

mm_sol/cli/examples/transfer-sol.toml

@@ -1,9 +0,0 @@
-routes = """
-Bd8CxCTLez2ckVTqEJjuZkWjYFSRbo8fA1qYbd7yFVP9 Eaft9xXzfgbRqsHd65WspoaxTtH7pkznM9YA8tsDKGwj
-Fc2TRJVCpFZpRz56mFnQETctib1zwFnwHcS7HoQSgUzZ EVJctTWikt29rUXBf49tyQdK87x837HtvpCwqeSjp1Ur
-"""
-private_keys = "file: ./path/to/privates.txt"
-value = "0.5balance - 0.012sol"
-delay = "random(5,10)"
-proxies = "url: https://site.com/api/get-proxies"
-nodes = "https://api.devnet.solana.com"

mm_sol/cli/examples/transfer-token.toml

@@ -1,9 +0,0 @@
-routes = """
-Bd8CxCTLez2ckVTqEJjuZkWjYFSRbo8fA1qYbd7yFVP9 Eaft9xXzfgbRqsHd65WspoaxTtH7pkznM9YA8tsDKGwj
-Fc2TRJVCpFZpRz56mFnQETctib1zwFnwHcS7HoQSgUzZ EVJctTWikt29rUXBf49tyQdK87x837HtvpCwqeSjp1Ur
-"""
-token = "6VBTMLgv256c7scudNf8T5GoTJcEE8WfgcJhxbGYPQ8G"
-private_keys = "file: ./path/to/privates.txt"
-value = "0.012 t"
-proxies = "https://site.com/api/get-proxies"
-nodes = "https://api.devnet.solana.com"