mm-sol 0.2.8__tar.gz → 0.2.10__tar.gz

{mm_sol-0.2.8 → mm_sol-0.2.10}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.2.8
+Version: 0.2.10
 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 → mm_sol-0.2.10}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "mm-sol"
-version = "0.2.8"
+version = "0.2.10"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
-    "mm-crypto-utils>=0.0.15",
+    "mm-crypto-utils>=0.0.19",
     "solana~=0.36.3",
     "base58~=2.1.1",
     "typer>=0.15.1",

mm_sol-0.2.10/src/mm_sol/cli/calcs.py

@@ -0,0 +1,49 @@
+import mm_crypto_utils
+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.constants import SUFFIX_DECIMALS
+
+
+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)
+
+
+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 calc_sol_value_for_address(*, nodes: Nodes, value_expression: str, address: str, proxies: Proxies, fee: int) -> Result[int]:
+    value_expression = value_expression.lower()
+    var = None
+    if "balance" in value_expression:
+        res = get_sol_balance_with_retries(nodes, address, proxies=proxies, retries=5)
+        if isinstance(res, Err):
+            return res
+        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_for_address(
+    *, nodes: Nodes, value_expression: str, wallet_address: str, token_mint_address: str, token_decimals: int, proxies: Proxies
+) -> Result[int]:
+    var = None
+    value_expression = value_expression.lower()
+    if "balance" in value_expression:
+        res = get_token_balance_with_retries(
+            nodes=nodes,
+            owner_address=wallet_address,
+            token_mint_address=token_mint_address,
+            proxies=proxies,
+            retries=5,
+        )
+        if isinstance(res, Err):
+            return res
+        var = VarInt("balance", res.ok)
+    value = calc_token_expression(value_expression, token_decimals, var)
+    return Ok(value)

{mm_sol-0.2.8 → mm_sol-0.2.10}/src/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-0.2.8 → mm_sol-0.2.10}/src/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-0.2.8 → mm_sol-0.2.10}/src/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-0.2.8 → mm_sol-0.2.10}/src/mm_sol/cli/cmd/transfer_sol_cmd.py

@@ -1,4 +1,3 @@
-import os
 import sys
 import time
 from pathlib import Path
@@ -8,31 +7,24 @@ 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, model_validator
 
 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
@@ -43,37 +35,9 @@ class Config(BaseConfig):
 
     @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
 
 
@@ -89,7 +53,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 +86,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 +96,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 +109,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 +133,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-0.2.8 → mm_sol-0.2.10}/src/mm_sol/cli/cmd/transfer_token_cmd.py

@@ -1,4 +1,3 @@
-import os
 import sys
 import time
 from pathlib import Path
@@ -9,29 +8,25 @@ 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, model_validator
 
-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
@@ -42,25 +37,9 @@ class Config(BaseConfig):
 
     @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
 
 
@@ -76,7 +55,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 +97,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 +110,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-0.2.10/src/mm_sol/cli/examples/transfer-sol.yml

@@ -0,0 +1,9 @@
+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.devnet.solana.com

mm_sol-0.2.8/src/mm_sol/cli/examples/transfer-sol.yml → mm_sol-0.2.10/src/mm_sol/cli/examples/transfer-token.yml

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

mm_sol-0.2.10/src/mm_sol/cli/validators.py

@@ -0,0 +1,32 @@
+from collections.abc import Callable
+
+from mm_crypto_utils import AddressToPrivate, ConfigValidators, TxRoute
+
+from mm_sol.account import get_public_key, is_address
+from mm_sol.constants import SUFFIX_DECIMALS
+
+
+class Validators(ConfigValidators):
+    @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-0.2.10/src/mm_sol/constants.py

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

{mm_sol-0.2.8 → mm_sol-0.2.10}/src/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-0.2.8 → mm_sol-0.2.10}/src/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 → mm_sol-0.2.10}/uv.lock

@@ -481,19 +481,19 @@ wheels = [
 
 [[package]]
 name = "mm-crypto-utils"
-version = "0.0.15"
+version = "0.0.19"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "loguru" },
     { name = "mm-std" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/50/1bbb9d11d0f799b71ae2a1a6f2d3724288e3d3698f0de5832f8ac86db482/mm_crypto_utils-0.0.15-py3-none-any.whl", hash = "sha256:950f7c11e43c17e9de8574def0e1b5d0a2d21db6027a77c8bbd91bded1be43c7", size = 6121 },
+    { url = "https://files.pythonhosted.org/packages/49/0b/408f661aba09bfc3625652a6cf2ba516874aaaa4f6c9eaaeca450cf70004/mm_crypto_utils-0.0.19-py3-none-any.whl", hash = "sha256:b51184a53aa78cb70253c3c2e0ad56a98a214a854ffb74a4130a4401cd025538", size = 6992 },
 ]
 
 [[package]]
 name = "mm-sol"
-version = "0.2.8"
+version = "0.2.10"
 source = { editable = "." }
 dependencies = [
     { name = "base58" },
@@ -518,7 +518,7 @@ dev = [
 requires-dist = [
     { name = "base58", specifier = "~=2.1.1" },
     { name = "jinja2", specifier = ">=3.1.5" },
-    { name = "mm-crypto-utils", specifier = ">=0.0.15" },
+    { name = "mm-crypto-utils", specifier = ">=0.0.19" },
     { name = "solana", specifier = "~=0.36.3" },
     { name = "typer", specifier = ">=0.15.1" },
 ]

mm_sol-0.2.8/src/mm_sol/cli/calcs.py

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

mm_sol-0.2.8/src/mm_sol/cli/validators.py

@@ -1,17 +0,0 @@
-from mm_crypto_utils import ConfigValidators
-
-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
-
-
-class Validators(ConfigValidators):
-    pass

mm_sol-0.2.8/tests/cli/test_calcs.py

@@ -1,28 +0,0 @@
-import pytest
-
-from mm_sol.cli import calcs
-from mm_sol.converters import to_lamports
-
-
-def test_calc_var_value():
-    assert calcs.calc_var_value("100") == 100
-    assert calcs.calc_var_value("10 + 2 - 5") == 7
-    assert calcs.calc_var_value("10 - random(2,2)") == 8
-    assert calcs.calc_var_value("1.5base + 1", var_value=10, var_name="base") == 16
-    assert calcs.calc_var_value("1.5estimate + 1", var_value=10, var_name="estimate") == 16
-    assert calcs.calc_var_value("12.2 sol") == to_lamports("12.2sol")
-    assert calcs.calc_var_value("12.2 t", decimals=6) == 12.2 * 10**6
-
-    with pytest.raises(ValueError):
-        calcs.calc_var_value("fff")
-    with pytest.raises(ValueError):
-        calcs.calc_var_value("12.3 sol + base", var_name="base")
-    with pytest.raises(ValueError):
-        calcs.calc_var_value("1.5estimate + 1", var_value=10)
-    with pytest.raises(ValueError):
-        calcs.calc_var_value("1.1t")
-
-
-# def test_calc_function_args():
-#     res = calcs.calc_function_args('["xxx", random(100,200), 100, "aaa", random(1,3)]')
-#     assert json.loads(res)[1] >= 100