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

mm_sol/cli/cmd/transfer_sol_cmd.py

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

mm_sol/cli/cmd/transfer_token_cmd.py

@@ -0,0 +1,135 @@
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Annotated, Self
+
+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 mm_sol.account import get_public_key, is_address
+from mm_sol.cli import calcs, cli_utils
+from mm_sol.cli.validators import Validators
+from mm_sol.token import get_decimals_with_retries
+
+
+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
+    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:
+        # 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,
+    *,
+    print_balances: bool,
+    print_config: bool,
+    debug: bool,
+    no_confirmation: bool,
+    emulate: bool,
+) -> None:
+    config = Config.read_config_or_exit(config_path)
+
+    if print_config:
+        config.print_and_exit({"private_keys", "proxies"})
+
+    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:
+        # cli_utils.print_balances(config.nodes, config.from_addresses, round_ndigits=config.round_ndigits, proxies=config.proxies) # noqa: E501
+        typer.echo("Not implemented yet")
+        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(
+        nodes=config.nodes,
+        value_str=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
+
+    logger.debug(f"{log_prefix}: value={value}, fee={fee}, no_confirmation={no_confirmation}, emulate={emulate}")

mm_sol/cli/cmd/wallet/keypair_cmd.py

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

mm_sol/cli/cmd/wallet/new_cmd.py

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

mm_sol/cli/examples/transfer-sol.yml

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

mm_sol/cli/validators.py

@@ -0,0 +1,17 @@
+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/converters.py

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

mm_sol/solana_cli.py

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

mm_sol/token.py

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