mm-sol 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

mm_sol/cli/calcs.py

@@ -1,92 +1,40 @@
-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_crypto_utils import Nodes, Proxies, VarInt
+from mm_std import Err, Ok, Result
 
 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
-
+from mm_sol.constants import SUFFIX_DECIMALS
 
-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
+def calc_sol_expression(expression: str, var: VarInt | None = None) -> int:
+    return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals=SUFFIX_DECIMALS)
 
-        return result  # noqa: TRY300
-    except Exception as err:
-        raise ValueError(f"wrong value: {value}, error={err}") from err
 
+def calc_token_expression(expression: str, token_decimals: int, var: VarInt | None = None) -> int:
+    return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals={"t": token_decimals})
 
-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():
+def calc_sol_value_for_address(*, nodes: Nodes, value_expression: str, address: str, proxies: Proxies, fee: int) -> Result[int]:
+    value_expression = value_expression.lower()
+    var = None
+    if "balance" in value_expression:
         res = get_sol_balance_with_retries(nodes, address, proxies=proxies, retries=5)
-        if res.is_err():
+        if isinstance(res, 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():
+        var = VarInt("balance", res.ok)
+
+    value = calc_sol_expression(value_expression, var)
+    if "balance" in value_expression:
         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
+def calc_token_value_for_address(
+    *, nodes: Nodes, value_expression: str, wallet_address: str, token_mint_address: str, token_decimals: int, proxies: Proxies
 ) -> Result[int]:
-    balance_value = None
-    if "balance" in value_str.lower():
+    var = None
+    value_expression = value_expression.lower()
+    if "balance" in value_expression:
         res = get_token_balance_with_retries(
             nodes=nodes,
             owner_address=wallet_address,
@@ -94,8 +42,8 @@ def calc_token_value(
             proxies=proxies,
             retries=5,
         )
-        if res.is_err():
+        if isinstance(res, Err):
             return res
-        balance_value = res.ok
-    value = calc_var_value(value_str, var_name="balance", var_value=balance_value, decimals=token_decimals)
+        var = VarInt("balance", res.ok)
+    value = calc_token_expression(value_expression, token_decimals, var)
     return Ok(value)

mm_sol/cli/cli.py

@@ -29,6 +29,7 @@ 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
 
 
 @app.command(name="example", help="Print an example of config for a command")

mm_sol/cli/cli_utils.py

@@ -1,11 +1,16 @@
 import importlib.metadata
+import time
 
-from mm_crypto_utils import Proxies
+import mm_crypto_utils
+from loguru import logger
+from mm_crypto_utils import Nodes, Proxies
 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
 from mm_sol.converters import lamports_to_sol
+from mm_sol.utils import get_client
 
 
 def get_version() -> str:
@@ -46,3 +51,22 @@ def print_balances(
             )
             row: list[str] = [str(count), address, balance]
             table.add_row(*row)
+
+
+def wait_confirmation(nodes: Nodes, proxies: Proxies, signature: Signature, log_prefix: str) -> bool:
+    count = 0
+    while True:
+        try:
+            node = mm_crypto_utils.random_node(nodes)
+            proxy = mm_crypto_utils.random_proxy(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/balances_cmd.py

@@ -1,39 +1,27 @@
-import os
 import random
 from decimal import Decimal
-from typing import Annotated, Any, Self
+from typing import Annotated, Any
 
-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 pydantic import BeforeValidator
 
 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
+from mm_sol.cli.validators import Validators
 
 
 class Config(BaseConfig):
-    accounts: Annotated[list[str], BeforeValidator(ConfigValidators.addresses(unique=True, is_address=is_address))]
+    accounts: Annotated[list[str], BeforeValidator(Validators.sol_addresses(unique=True))]
+    tokens: Annotated[list[str], BeforeValidator(Validators.sol_addresses(unique=True))]
     nodes: Annotated[list[str], BeforeValidator(ConfigValidators.nodes())]
-    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)
+    proxies: Annotated[list[str], BeforeValidator(Validators.proxies())]
 
     @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)

mm_sol/cli/cmd/transfer_sol_cmd.py

@@ -1,38 +1,30 @@
-import os
 import sys
 import time
 from pathlib import Path
-from typing import Annotated, Self
+from typing import Annotated
 
 import mm_crypto_utils
 from loguru import logger
 from mm_crypto_utils import AddressToPrivate, TxRoute
 from mm_std import BaseConfig, Err, utc_now
-from pydantic import BeforeValidator, Field, model_validator
-from solders.signature import Signature
+from pydantic import AfterValidator, BeforeValidator
 
 from mm_sol import transfer
-from mm_sol.account import get_public_key, is_address
-from mm_sol.cli import calcs, cli_utils, validators
+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
-from mm_sol.utils import get_client
 
 
+# noinspection DuplicatedCode
 class Config(BaseConfig):
     nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
-    routes: Annotated[list[TxRoute], BeforeValidator(Validators.routes(is_address))]
-    routes_from_file: Path | None = None
-    routes_to_file: Path | None = None
-    private_keys: Annotated[
-        AddressToPrivate, Field(default_factory=AddressToPrivate), BeforeValidator(Validators.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
+    routes: Annotated[list[TxRoute], BeforeValidator(Validators.sol_routes())]
+    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.sol_private_keys())]
+    proxies: Annotated[list[str], 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
@@ -41,41 +33,6 @@ class Config(BaseConfig):
     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_address)
-        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}")
-
-        return self
-
 
 def run(
     config_path: str,
@@ -89,7 +46,7 @@ def run(
     config = Config.read_config_or_exit(config_path)
 
     if print_config:
-        config.print_and_exit({"private_keys", "proxies"})
+        config.print_and_exit({"private_keys"})
 
     mm_crypto_utils.init_logger(debug, config.log_debug, config.log_info)
 
@@ -122,8 +79,8 @@ def _transfer(*, from_address: str, to_address: str, config: Config, no_confirma
     log_prefix = f"{from_address}->{to_address}"
     fee = 5000
     # get value
-    value_res = calcs.calc_sol_value(
-        nodes=config.nodes, value_str=config.value, address=from_address, proxies=config.proxies, fee=fee
+    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):
@@ -132,14 +89,11 @@ def _transfer(*, from_address: str, to_address: str, config: Config, no_confirma
     value = value_res.ok
 
     # 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,
-    }
+    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:
@@ -148,7 +102,8 @@ def _transfer(*, from_address: str, to_address: str, config: Config, no_confirma
         logger.info(msg)
         return
 
-    logger.debug(f"{log_prefix}: tx_params={tx_params}")
+    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,
@@ -171,26 +126,7 @@ def _transfer(*, from_address: str, to_address: str, config: Config, no_confirma
     else:
         logger.debug(f"{log_prefix}: sig={signature}, waiting for confirmation")
         status = "UNKNOWN"
-        if _wait_confirmation(config, signature, log_prefix):
+        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 _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/transfer_token_cmd.py

@@ -1,37 +1,32 @@
-import os
 import sys
 import time
 from pathlib import Path
-from typing import Annotated, Self
+from typing import Annotated
 
 import mm_crypto_utils
 import typer
 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 pydantic import AfterValidator, BeforeValidator
 
-from mm_sol.account import get_public_key, is_address
+from mm_sol import transfer
 from mm_sol.cli import calcs, cli_utils
 from mm_sol.cli.validators import Validators
+from mm_sol.converters import 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.routes(is_address))]
-    routes_from_file: Path | None = None
-    routes_to_file: Path | None = None
-    private_keys: Annotated[
-        AddressToPrivate, Field(default_factory=AddressToPrivate), BeforeValidator(Validators.private_keys(get_public_key))
-    ]
-    private_keys_file: Path | None = None
-    proxies_url: str | None = None
-    proxies: list[str] = Field(default_factory=list)
-    token: Annotated[str, AfterValidator(Validators.address(is_address))]
-    value: str
-    value_min_limit: str | None = None
-    delay: str | None = None  # in seconds
+    routes: Annotated[list[TxRoute], BeforeValidator(Validators.sol_routes())]
+    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.sol_private_keys())]
+    proxies: Annotated[list[str], 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
@@ -40,29 +35,6 @@ class Config(BaseConfig):
     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_address)
-        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)
-
-        return self
-
 
 def run(
     config_path: str,
@@ -76,7 +48,7 @@ def run(
     config = Config.read_config_or_exit(config_path)
 
     if print_config:
-        config.print_and_exit({"private_keys", "proxies"})
+        config.print_and_exit({"private_keys"})
 
     mm_crypto_utils.init_logger(debug, config.log_debug, config.log_info)
 
@@ -118,9 +90,9 @@ def _transfer(*, route: TxRoute, config: Config, token_decimals: int, no_confirm
     fee = 5000
 
     # get value
-    value_res = calcs.calc_token_value(
+    value_res = calcs.calc_token_value_for_address(
         nodes=config.nodes,
-        value_str=config.value,
+        value_expression=config.value,
         wallet_address=route.from_address,
         proxies=config.proxies,
         token_mint_address=config.token,
@@ -131,5 +103,44 @@ def _transfer(*, route: TxRoute, config: Config, token_decimals: int, no_confirm
         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={value}, fee={fee}, no_confirmation={no_confirmation}, emulate={emulate}")
+    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)

mm_sol/cli/examples/transfer-sol.yml

@@ -1,11 +1,9 @@
-tx_routes: |
+routes: |
   Bd8CxCTLez2ckVTqEJjuZkWjYFSRbo8fA1qYbd7yFVP9 Eaft9xXzfgbRqsHd65WspoaxTtH7pkznM9YA8tsDKGwj
   Fc2TRJVCpFZpRz56mFnQETctib1zwFnwHcS7HoQSgUzZ EVJctTWikt29rUXBf49tyQdK87x837HtvpCwqeSjp1Ur
-
-
-private_keys_file: ./path/to/privates.txt
+private_keys: "file: ./path/to/privates.txt"
 value: 0.012 sol
 
-proxies_url: https://site.com/api/get-proxies
+proxies: "url: https://site.com/api/get-proxies"
 nodes: |
   https://api.devnet.solana.com

mm_sol/cli/examples/transfer-token.yml

@@ -0,0 +1,11 @@
+routes: |
+  Bd8CxCTLez2ckVTqEJjuZkWjYFSRbo8fA1qYbd7yFVP9 Eaft9xXzfgbRqsHd65WspoaxTtH7pkznM9YA8tsDKGwj
+  Fc2TRJVCpFZpRz56mFnQETctib1zwFnwHcS7HoQSgUzZ EVJctTWikt29rUXBf49tyQdK87x837HtvpCwqeSjp1Ur
+token: 6VBTMLgv256c7scudNf8T5GoTJcEE8WfgcJhxbGYPQ8G
+
+private_keys_file: ./path/to/privates.txt
+value: 0.012 t
+
+proxies_url: https://site.com/api/get-proxies
+nodes: |
+  https://api.devnet.solana.com

mm_sol/cli/validators.py

@@ -1,17 +1,32 @@
-from mm_crypto_utils import ConfigValidators
+from collections.abc import Callable
 
-from mm_sol.cli import calcs
+from mm_crypto_utils import AddressToPrivate, ConfigValidators, TxRoute
 
-
-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
+from mm_sol.account import get_public_key, is_address
+from mm_sol.constants import SUFFIX_DECIMALS
 
 
 class Validators(ConfigValidators):
-    pass
+    @staticmethod
+    def sol_address() -> Callable[[str], str]:
+        return ConfigValidators.address(is_address)
+
+    @staticmethod
+    def sol_addresses(unique: bool) -> Callable[[str | list[str] | None], list[str]]:
+        return ConfigValidators.addresses(unique, is_address=is_address)
+
+    @staticmethod
+    def sol_routes() -> Callable[[str | None], list[TxRoute]]:
+        return ConfigValidators.routes(is_address)
+
+    @staticmethod
+    def sol_private_keys() -> Callable[[str | list[str] | None], AddressToPrivate]:
+        return ConfigValidators.private_keys(get_public_key)
+
+    @staticmethod
+    def valid_sol_expression(var_name: str | None = None) -> Callable[[str], str]:
+        return ConfigValidators.valid_calc_int_expression(var_name, SUFFIX_DECIMALS)
+
+    @staticmethod
+    def valid_token_expression(var_name: str | None = None) -> Callable[[str], str]:
+        return ConfigValidators.valid_calc_int_expression(var_name, {"t": 6})

mm_sol/constants.py

@@ -0,0 +1 @@
+SUFFIX_DECIMALS = {"sol": 9}

mm_sol/converters.py

@@ -5,6 +5,10 @@ def lamports_to_sol(lamports: int, ndigits: int = 4) -> Decimal:
     return Decimal(str(round(lamports / 10**9, ndigits=ndigits)))
 
 
+def to_token(smallest_unit_value: int, decimals: int, ndigits: int = 4) -> Decimal:
+    return Decimal(str(round(smallest_unit_value / 10**decimals, ndigits=ndigits)))
+
+
 def sol_to_lamports(sol: Decimal) -> int:
     return int(sol * 10**9)
 

mm_sol/transfer.py

@@ -1,5 +1,3 @@
-from decimal import Decimal
-
 import mm_crypto_utils
 import pydash
 from mm_crypto_utils import Nodes, Proxies
@@ -14,7 +12,6 @@ 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
 
@@ -26,7 +23,7 @@ def transfer_token(
     from_address: str | Pubkey,
     private_key: str,
     to_address: str | Pubkey,
-    amount: Decimal,
+    amount: int,  # smallest unit
     decimals: int,
     proxy: str | None = None,
     timeout: float = 10,
@@ -60,7 +57,7 @@ def transfer_token(
         source=from_token_account,
         dest=recipient_token_account,
         owner=from_address,
-        amount=mm_sol.converters.sol_to_lamports(amount),
+        amount=amount,
         decimals=decimals,
     )
     data.append(res)
@@ -75,7 +72,7 @@ def transfer_token_with_retries(
     from_address: str | Pubkey,
     private_key: str,
     to_address: str | Pubkey,
-    amount: Decimal,
+    amount: int,  # smallest unit
     decimals: int,
     proxies: Proxies = None,
     timeout: float = 10,

{mm_sol-0.2.8.dist-info → mm_sol-0.2.9.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.2.8
+Version: 0.2.9
 Requires-Python: >=3.12
 Requires-Dist: base58~=2.1.1
 Requires-Dist: jinja2>=3.1.5
-Requires-Dist: mm-crypto-utils>=0.0.15
+Requires-Dist: mm-crypto-utils>=0.0.19
 Requires-Dist: solana~=0.36.3
 Requires-Dist: typer>=0.15.1

{mm_sol-0.2.8.dist-info → mm_sol-0.2.9.dist-info}/RECORD

@@ -2,31 +2,33 @@ mm_sol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_sol/account.py,sha256=32PR3kAoZJLEtKzwfWeQXnMxZeFO8NVXjG8HnHpnJgM,3225
 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/constants.py,sha256=WSpfz5_cq_8XbIrNFJGu9okwbfPTL00zsyR_k9-7O0o,29
+mm_sol/converters.py,sha256=CevrVjQHkAbtllrig8_-hU0go0YlOkWa8YebxUpqXJk,1323
 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=O8z3UE3iZGYLWw8fnd9weYMcoQO0m88noqbRO_jntGg,1092
-mm_sol/transfer.py,sha256=-76gSHbQGOZeOgVgo10QWjAcv_9mnGrBNvpRCvXBlZQ,5872
+mm_sol/transfer.py,sha256=Gu6UYEjY5OECSusKJO-VA8C3B7W6ZJGjegUv67EQdfs,5809
 mm_sol/utils.py,sha256=NE0G564GiT9d7rW_lPPxUb1eq62WiXh28xtvtzNQIqw,556
 mm_sol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/calcs.py,sha256=jtFTODBHOkeSR5SARksQ7dDw2BATQYdhc8PtUskfEPk,4152
-mm_sol/cli/cli.py,sha256=SZwvxbiEXHgnhZ_Zg7GsgOm0Y2-WYHSQSuaO2xTaOnk,4496
-mm_sol/cli/cli_utils.py,sha256=EJTWdccXg8mvkK7E-Dt7zmULzc1WoqFlbu8ASGT2SVI,1381
-mm_sol/cli/validators.py,sha256=uKAZfKx4a11kLnxnD98duCMUEswj9UTJkWVVjlW0cDw,500
+mm_sol/cli/calcs.py,sha256=-r9RlsQyOziTDf84uIsvTgZmsUdNrVeazu3vTj9hhNA,1887
+mm_sol/cli/cli.py,sha256=p0urdRiho7Q8DgvUdH79wiujnnf3VIG24uKcFpmF-Yw,4556
+mm_sol/cli/cli_utils.py,sha256=Skj0SCHPWMHGr2ag-em1JtIK9Qdh7xeJafMzvCgChnc,2254
+mm_sol/cli/validators.py,sha256=_HEMOG7ojGKNp8AHX9tXpo9ZDCeRJ85coI-5MO3u95s,1209
 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=yfiRMR3inxz0eXKR4rC9Ii8XsED_3mn46LX_C6Zf0MA,2624
+mm_sol/cli/cmd/balances_cmd.py,sha256=P2WRCqJXKo36Pqfe-ZrpguggVmpXTMXr-hQeji6-Bb0,2184
 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=BmPCKr9D1rc7EQ9fuuShlrhiYYli1v1EHY3gkygrFJU,7083
-mm_sol/cli/cmd/transfer_token_cmd.py,sha256=bfDhy0s1i9qaXeGWLk1CnSnxS6wJKdDAM4f3f07RWJA,5148
+mm_sol/cli/cmd/transfer_sol_cmd.py,sha256=eRLKkr8ur3tNt_OG8pQapFqSLrzW7u9irKIpNbDWFuM,5035
+mm_sol/cli/cmd/transfer_token_cmd.py,sha256=8d_cTsMP1NnwdCBgM-hVxDjwXsTe3CHgoL2JEuknvWQ,5633
 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.8.dist-info/METADATA,sha256=ijsNaal8AmUCRafckp2F6XPP_D1Ejn9RU4pwdq839cA,230
-mm_sol-0.2.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_sol-0.2.8.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
-mm_sol-0.2.8.dist-info/RECORD,,
+mm_sol/cli/examples/transfer-sol.yml,sha256=d0kO2FHNEXMD6WSjOk6X7PtDuaGAAQWn098k8z5bgbs,347
+mm_sol/cli/examples/transfer-token.yml,sha256=d8-3GE6NeM5zXo9S6WA8OP6pHjoEZvf7mtu9JwS5SZY,392
+mm_sol-0.2.9.dist-info/METADATA,sha256=YqSKksvBVs1tF2FlFiGe8rrPjqR3rbaftUHr4NKEtlQ,230
+mm_sol-0.2.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_sol-0.2.9.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.2.9.dist-info/RECORD,,